@whatwg-node/node-fetch 0.0.1-alpha-20221005123855-1e2f172

package/index.js

@@ -0,0 +1,624 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const http = require('http');
+const https = require('https');
+const buffer = require('buffer');
+const stream = require('stream');
+
+class PonyfillAbortError extends Error {
+    constructor() {
+        super('The operation was aborted.');
+        this.name = 'AbortError';
+    }
+}
+
+class PonyfillAbortSignal extends EventTarget {
+    constructor() {
+        super(...arguments);
+        this.aborted = false;
+        this._onabort = null;
+    }
+    throwIfAborted() {
+        throw new PonyfillAbortError();
+    }
+    get onabort() {
+        return this._onabort;
+    }
+    set onabort(value) {
+        if (this._onabort) {
+            this.removeEventListener('abort', this._onabort);
+        }
+        this.addEventListener('abort', value);
+    }
+}
+
+class PonyfillAbortController {
+    constructor() {
+        this.signal = new PonyfillAbortSignal();
+    }
+    abort(reason) {
+        this.signal.dispatchEvent(Object.assign(new Event('abort'), { reason }));
+    }
+}
+
+const PonyfillBlob = buffer.Blob;
+
+class PonyfillFile extends PonyfillBlob {
+    constructor(fileBits, name, options) {
+        super(fileBits, options);
+        this.name = name;
+        this.webkitRelativePath = '';
+        this.lastModified = (options === null || options === void 0 ? void 0 : options.lastModified) || Date.now();
+    }
+}
+
+class PonyfillFormData {
+    constructor() {
+        this.map = new Map();
+    }
+    append(name, value, fileName) {
+        let values = this.map.get(name);
+        if (!values) {
+            values = [];
+            this.map.set(name, values);
+        }
+        const entry = value instanceof PonyfillBlob ? this.getNormalizedFile(name, value, fileName) : value;
+        values.push(entry);
+    }
+    delete(name) {
+        this.map.delete(name);
+    }
+    get(name) {
+        const values = this.map.get(name);
+        return values ? values[0] : null;
+    }
+    getAll(name) {
+        return this.map.get(name) || [];
+    }
+    has(name) {
+        return this.map.has(name);
+    }
+    set(name, value, fileName) {
+        const entry = value instanceof PonyfillBlob ? this.getNormalizedFile(name, value, fileName) : value;
+        this.map.set(name, [entry]);
+    }
+    getNormalizedFile(name, blob, fileName) {
+        if (blob instanceof PonyfillFile) {
+            if (fileName == null) {
+                return new PonyfillFile([blob], name, { type: blob.type, lastModified: blob.lastModified });
+            }
+            return blob;
+        }
+        return new PonyfillFile([blob], fileName || name, { type: blob.type });
+    }
+    forEach(callback) {
+        for (const [key, values] of this.map) {
+            for (const value of values) {
+                callback(value, key, this);
+            }
+        }
+    }
+}
+
+function createController(desiredSize, readable) {
+    return {
+        desiredSize,
+        enqueue(chunk) {
+            readable.push(chunk);
+        },
+        close() {
+            readable.push(null);
+        },
+        error(error) {
+            readable.destroy(error);
+        }
+    };
+}
+class PonyfillReadableStream {
+    constructor(underlyingSource) {
+        this.locked = false;
+        let started = false;
+        if (underlyingSource instanceof PonyfillReadableStream) {
+            this.readable = underlyingSource.readable;
+        }
+        else if (underlyingSource && 'read' in underlyingSource) {
+            this.readable = underlyingSource;
+        }
+        else if (underlyingSource && 'getReader' in underlyingSource) {
+            const reader = underlyingSource.getReader();
+            this.readable = new stream.Readable({
+                read() {
+                    reader.read().then(({ value, done }) => {
+                        if (done) {
+                            this.push(null);
+                        }
+                        else {
+                            this.push(value);
+                        }
+                    }).catch(err => {
+                        this.destroy(err);
+                    });
+                },
+                destroy(err, callback) {
+                    reader.cancel(err).then(() => callback(err), callback);
+                }
+            });
+        }
+        else {
+            this.readable = new stream.Readable({
+                read(desiredSize) {
+                    var _a, _b;
+                    if (!started) {
+                        started = true;
+                        (_a = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.start) === null || _a === void 0 ? void 0 : _a.call(underlyingSource, createController(desiredSize, this));
+                    }
+                    (_b = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.pull) === null || _b === void 0 ? void 0 : _b.call(underlyingSource, createController(desiredSize, this));
+                },
+                async destroy(err, callback) {
+                    var _a;
+                    try {
+                        await ((_a = underlyingSource === null || underlyingSource === void 0 ? void 0 : underlyingSource.cancel) === null || _a === void 0 ? void 0 : _a.call(underlyingSource, err));
+                        callback(null);
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                }
+            });
+        }
+    }
+    cancel(reason) {
+        this.readable.destroy(reason);
+        return Promise.resolve();
+    }
+    getReader() {
+        const iterator = this.readable[Symbol.asyncIterator]();
+        return {
+            read() {
+                return iterator.next();
+            },
+            releaseLock: () => {
+                var _a;
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+                this.locked = false;
+            },
+            cancel: async (reason) => {
+                var _a;
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator, reason));
+                this.locked = false;
+            },
+            closed: new Promise((resolve, reject) => {
+                this.readable.once('end', resolve);
+                this.readable.once('error', reject);
+            }),
+        };
+    }
+    [Symbol.asyncIterator]() {
+        return this.readable[Symbol.asyncIterator]();
+    }
+    tee() {
+        throw new Error('Not implemented');
+    }
+    async pipeTo(destination) {
+        const writer = destination.getWriter();
+        await writer.ready;
+        for await (const chunk of this.readable) {
+            await writer.write(chunk);
+        }
+        await writer.ready;
+        return writer.close();
+    }
+    pipeThrough({ writable, readable }) {
+        this.pipeTo(writable);
+        return readable;
+    }
+}
+
+var BodyInitType;
+(function (BodyInitType) {
+    BodyInitType["ReadableStream"] = "ReadableStream";
+    BodyInitType["Blob"] = "Blob";
+    BodyInitType["FormData"] = "FormData";
+    BodyInitType["ArrayBuffer"] = "ArrayBuffer";
+    BodyInitType["String"] = "String";
+    BodyInitType["Readable"] = "Readable";
+})(BodyInitType || (BodyInitType = {}));
+class BodyPonyfill {
+    constructor(bodyInit) {
+        this.bodyInit = bodyInit;
+        this.bodyUsed = false;
+        this.contentType = null;
+        this.contentLength = null;
+        this._bodyProcessed = false;
+        this._processedBody = null;
+    }
+    get body() {
+        if (!this._bodyProcessed) {
+            this._processedBody = this.processBody();
+            this._bodyProcessed = true;
+        }
+        return this._processedBody;
+    }
+    processBody() {
+        if (this.bodyInit == null) {
+            return null;
+        }
+        if (typeof this.bodyInit === 'string') {
+            this.bodyType = BodyInitType.String;
+            const buffer = Buffer.from(this.bodyInit);
+            this.contentType = 'text/plain;charset=UTF-8';
+            this.contentLength = buffer.length;
+            return new PonyfillReadableStream(stream.Readable.from(buffer));
+        }
+        else if (this.bodyInit instanceof PonyfillReadableStream) {
+            this.bodyType = BodyInitType.ReadableStream;
+            return this.bodyInit;
+        }
+        else if (this.bodyInit instanceof PonyfillBlob) {
+            this.bodyType = BodyInitType.Blob;
+            const blobStream = this.bodyInit.stream();
+            this.contentType = this.bodyInit.type;
+            this.contentLength = this.bodyInit.size;
+            return new PonyfillReadableStream(blobStream);
+        }
+        else if (this.bodyInit instanceof PonyfillFormData) {
+            this.bodyType = BodyInitType.FormData;
+            const boundary = Math.random().toString(36).substr(2);
+            const formData = this.bodyInit;
+            this.contentType = `multipart/form-data; boundary=${boundary}`;
+            return new PonyfillReadableStream({
+                start: async (controller) => {
+                    controller.enqueue(Buffer.from(`--${boundary}\r\n`));
+                    const entries = [];
+                    formData.forEach((value, key) => {
+                        entries.push([key, value]);
+                    });
+                    for (const i in entries) {
+                        const [key, value] = entries[i];
+                        if (value instanceof PonyfillBlob) {
+                            let filenamePart = '';
+                            if (value.name) {
+                                filenamePart = `; filename="${value.name}"`;
+                            }
+                            controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"${filenamePart}\r\n`));
+                            controller.enqueue(Buffer.from(`Content-Type: ${value.type || 'application/octet-stream'}\r\n\r\n`));
+                            controller.enqueue(Buffer.from(await value.arrayBuffer()));
+                        }
+                        else {
+                            controller.enqueue(Buffer.from(`Content-Disposition: form-data; name="${key}"\r\n\r\n`));
+                            controller.enqueue(Buffer.from(value));
+                        }
+                        if (Number(i) === (entries.length - 1)) {
+                            controller.enqueue(Buffer.from(`\r\n--${boundary}--\r\n`));
+                        }
+                        else {
+                            controller.enqueue(Buffer.from(`\r\n--${boundary}\r\n`));
+                        }
+                    }
+                    controller.close();
+                }
+            });
+        }
+        else if ('buffer' in this.bodyInit) {
+            this.contentLength = this.bodyInit.byteLength;
+            return new PonyfillReadableStream(stream.Readable.from(this.bodyInit));
+        }
+        else if (this.bodyInit instanceof ArrayBuffer) {
+            this.bodyType = BodyInitType.ArrayBuffer;
+            this.contentLength = this.bodyInit.byteLength;
+            return new PonyfillReadableStream(stream.Readable.from(Buffer.from(this.bodyInit)));
+        }
+        else if (this.bodyInit instanceof stream.Readable) {
+            this.bodyType = BodyInitType.Readable;
+            return new PonyfillReadableStream(this.bodyInit);
+        }
+        else {
+            throw new Error('Unknown body type');
+        }
+    }
+    async arrayBuffer() {
+        if (this.bodyType === BodyInitType.ArrayBuffer) {
+            return this.bodyInit;
+        }
+        const blob = await this.blob();
+        return blob.arrayBuffer();
+    }
+    async blob() {
+        if (this.bodyType === BodyInitType.Blob) {
+            return this.bodyInit;
+        }
+        const chunks = [];
+        if (this.body) {
+            for await (const chunk of this.body.readable) {
+                chunks.push(chunk);
+            }
+        }
+        return new PonyfillBlob(chunks);
+    }
+    async formData() {
+        if (this.bodyType === BodyInitType.FormData) {
+            return this.bodyInit;
+        }
+        throw new Error('Not implemented');
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    async text() {
+        if (this.bodyType === BodyInitType.String) {
+            return this.bodyInit;
+        }
+        const blob = await this.blob();
+        return blob.text();
+    }
+    readable() {
+        if (this.bodyType === BodyInitType.Readable) {
+            return this.bodyInit;
+        }
+        if (this.body != null) {
+            return this.body.readable;
+        }
+        return null;
+    }
+}
+
+class PonyfillHeaders {
+    constructor(headersInit) {
+        this.map = new Map();
+        if (headersInit != null) {
+            if (Array.isArray(headersInit)) {
+                for (const [key, value] of headersInit) {
+                    if (Array.isArray(value)) {
+                        for (const v of value) {
+                            this.append(key, v);
+                        }
+                    }
+                    else {
+                        this.map.set(key, value);
+                    }
+                }
+            }
+            else if ('get' in headersInit) {
+                headersInit.forEach((value, key) => {
+                    this.set(key, value);
+                });
+            }
+            else {
+                for (const key in headersInit) {
+                    const value = headersInit[key];
+                    if (Array.isArray(value)) {
+                        for (const v of value) {
+                            this.append(key, v);
+                        }
+                    }
+                    else if (value != null) {
+                        this.set(key, value);
+                    }
+                }
+            }
+        }
+    }
+    append(name, value) {
+        const key = name.toLowerCase();
+        if (this.map.has(key)) {
+            value = this.map.get(key) + ', ' + value;
+        }
+        else {
+            this.map.set(key, value);
+        }
+    }
+    get(name) {
+        const key = name.toLowerCase();
+        return this.map.get(key) || null;
+    }
+    has(name) {
+        const key = name.toLowerCase();
+        return this.map.has(key);
+    }
+    set(name, value) {
+        const key = name.toLowerCase();
+        this.map.set(key, value);
+    }
+    delete(name) {
+        const key = name.toLowerCase();
+        this.map.delete(key);
+    }
+    forEach(callback) {
+        this.map.forEach((value, key) => {
+            callback(value, key, this);
+        });
+    }
+}
+
+function isRequest(input) {
+    return input[Symbol.toStringTag] === 'Request';
+}
+class PonyfillRequest extends BodyPonyfill {
+    constructor(input, options) {
+        let url;
+        let bodyInit = null;
+        let requestInit;
+        if (typeof input === 'string') {
+            url = input;
+        }
+        else if (input instanceof URL) {
+            url = input.toString();
+        }
+        else if (isRequest(input)) {
+            url = input.url;
+            bodyInit = input.body;
+            requestInit = input;
+        }
+        if (options != null) {
+            bodyInit = options.body || null;
+            requestInit = options;
+        }
+        super(bodyInit);
+        this.postProcessedBody = false;
+        this.destination = '';
+        this.priority = 'auto';
+        this.cache = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.cache) || 'default';
+        this.credentials = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.credentials) || 'same-origin';
+        this.headers = new PonyfillHeaders(requestInit === null || requestInit === void 0 ? void 0 : requestInit.headers);
+        this.integrity = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.integrity) || '';
+        this.keepalive = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.keepalive) || true;
+        this.method = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.method) || 'GET';
+        this.mode = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.mode) || 'cors';
+        this.redirect = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.redirect) || 'follow';
+        this.referrer = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.referrer) || 'about:client';
+        this.referrerPolicy = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.referrerPolicy) || 'no-referrer';
+        this.signal = (requestInit === null || requestInit === void 0 ? void 0 : requestInit.signal) || new PonyfillAbortController().signal;
+        this.url = url || '';
+        if (this.keepalive) {
+            if (!this.headers.has('connection')) {
+                this.headers.set('connection', 'keep-alive');
+            }
+        }
+    }
+    get body() {
+        const actualBody = super.body;
+        if (!this.postProcessedBody) {
+            this.postProcessBody();
+        }
+        return actualBody;
+    }
+    postProcessBody() {
+        if (!this.headers.has('content-type')) {
+            if (this.contentType) {
+                this.headers.set('content-type', this.contentType);
+            }
+        }
+        if (!this.headers.has('content-length')) {
+            if (this.contentLength) {
+                this.headers.set('content-length', this.contentLength.toString());
+            }
+        }
+    }
+    clone() {
+        return new Request(this);
+    }
+}
+
+class PonyfillResponse extends BodyPonyfill {
+    constructor(body, init) {
+        super(body || null);
+        this.headers = new PonyfillHeaders();
+        this.status = 200;
+        this.statusText = 'OK';
+        this.url = '';
+        this.redirected = false;
+        this.type = 'default';
+        if (init) {
+            this.headers = new PonyfillHeaders(init.headers);
+            this.status = init.status || 200;
+            this.statusText = init.statusText || 'OK';
+            this.url = init.url || '';
+            this.redirected = init.redirected || false;
+        }
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    clone() {
+        return new PonyfillResponse(this.body, this);
+    }
+    static error() {
+        const response = new PonyfillResponse(null, {
+            status: 500,
+            statusText: 'Internal Server Error'
+        });
+        return response;
+    }
+    static redirect(url, status = 301) {
+        if (status < 300 || status > 399) {
+            throw new RangeError('Invalid status code');
+        }
+        return new PonyfillResponse(null, {
+            headers: {
+                location: url
+            },
+            status
+        });
+    }
+}
+
+function getHeadersObj(headers) {
+    if (headers == null || !('forEach' in headers)) {
+        return headers;
+    }
+    const obj = {};
+    headers.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+
+const fetchPonyfill = (info, init) => {
+    if (typeof info === 'string' || info instanceof URL) {
+        return fetchPonyfill(new PonyfillRequest(info, init));
+    }
+    const fetchRequest = info;
+    return new Promise((resolve, reject) => {
+        try {
+            const requestFn = fetchRequest.url.startsWith('https') ? https.request : http.request;
+            const nodeReadable = fetchRequest.readable();
+            const nodeHeaders = getHeadersObj(fetchRequest.headers);
+            const abortListener = function abortListener() {
+                reject(new PonyfillAbortError());
+            };
+            fetchRequest.signal.addEventListener('abort', abortListener);
+            const nodeRequest = requestFn(fetchRequest.url, {
+                method: fetchRequest.method,
+                headers: nodeHeaders,
+                signal: fetchRequest.signal,
+            }, nodeResponse => {
+                if (nodeResponse.headers.location) {
+                    if (fetchRequest.redirect === 'error') {
+                        reject(new Error('Redirects are not allowed'));
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        resolve(fetchPonyfill(new URL(nodeResponse.headers.location, info.url), info).then(resp => {
+                            resp.redirected = true;
+                            return resp;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                const responseHeaders = nodeResponse.headers;
+                resolve(new PonyfillResponse(nodeResponse, {
+                    status: nodeResponse.statusCode,
+                    statusText: nodeResponse.statusMessage,
+                    headers: responseHeaders,
+                    url: info.url,
+                }));
+            });
+            if (nodeReadable) {
+                nodeReadable.pipe(nodeRequest);
+            }
+            else {
+                nodeRequest.end();
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+};
+
+exports.AbortController = PonyfillAbortController;
+exports.AbortError = PonyfillAbortError;
+exports.AbortSignal = PonyfillAbortSignal;
+exports.Blob = PonyfillBlob;
+exports.File = PonyfillFile;
+exports.FormData = PonyfillFormData;
+exports.Headers = PonyfillHeaders;
+exports.ReadableStream = PonyfillReadableStream;
+exports.Request = PonyfillRequest;
+exports.Response = PonyfillResponse;
+exports.fetch = fetchPonyfill;