@whatwg-node/node-fetch 0.3.3-rc-20230320123406-da3a60b → 0.3.3

package/cjs/URLSearchParams.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillURLSearchParams = void 0;
+const tslib_1 = require("tslib");
+const fast_querystring_1 = tslib_1.__importDefault(require("fast-querystring"));
+class PonyfillURLSearchParams {
+    constructor(init) {
+        if (init) {
+            if (typeof init === 'string') {
+                this.params = fast_querystring_1.default.parse(init);
+            }
+            else if (Array.isArray(init)) {
+                this.params = {};
+                for (const [key, value] of init) {
+                    this.params[key] = value;
+                }
+            }
+            else if ('entries' in init) {
+                this.params = {};
+                for (const [key, value] of init.entries()) {
+                    this.params[key] = value;
+                }
+            }
+            else {
+                this.params = init;
+            }
+        }
+        else {
+            this.params = {};
+        }
+    }
+    append(name, value) {
+        const existingValue = this.params[name];
+        const finalValue = existingValue ? `${existingValue},${value}` : value;
+        this.params[name] = finalValue;
+    }
+    delete(name) {
+        delete this.params[name];
+    }
+    get(name) {
+        const value = this.params[name];
+        if (Array.isArray(value)) {
+            return value[0] || null;
+        }
+        return value || null;
+    }
+    getAll(name) {
+        const value = this.params[name];
+        if (!Array.isArray(value)) {
+            return value ? [value] : [];
+        }
+        return value;
+    }
+    has(name) {
+        return name in this.params;
+    }
+    set(name, value) {
+        this.params[name] = value;
+    }
+    sort() {
+        const sortedKeys = Object.keys(this.params).sort();
+        const sortedParams = {};
+        for (const key of sortedKeys) {
+            sortedParams[key] = this.params[key];
+        }
+        this.params = sortedParams;
+    }
+    toString() {
+        return fast_querystring_1.default.stringify(this.params);
+    }
+    *keys() {
+        for (const key in this.params) {
+            yield key;
+        }
+    }
+    *entries() {
+        for (const key of this.keys()) {
+            const value = this.params[key];
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    yield [key, item];
+                }
+            }
+            else {
+                yield [key, value];
+            }
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    forEach(callback) {
+        for (const [key, value] of this) {
+            callback(value, key, this);
+        }
+    }
+}
+exports.PonyfillURLSearchParams = PonyfillURLSearchParams;

package/cjs/fetch.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPonyfill = void 0;
+const fs_1 = require("fs");
+const http_1 = require("http");
+const https_1 = require("https");
+const stream_1 = require("stream");
+const url_1 = require("url");
+const zlib_1 = require("zlib");
+const AbortError_js_1 = require("./AbortError.js");
+const Blob_js_1 = require("./Blob.js");
+const Request_js_1 = require("./Request.js");
+const Response_js_1 = require("./Response.js");
+const URL_js_1 = require("./URL.js");
+const utils_js_1 = require("./utils.js");
+function getResponseForFile(url) {
+    const path = (0, url_1.fileURLToPath)(url);
+    const readable = (0, fs_1.createReadStream)(path);
+    return new Response_js_1.PonyfillResponse(readable);
+}
+function getRequestFnForProtocol(protocol) {
+    switch (protocol) {
+        case 'http:':
+            return http_1.request;
+        case 'https:':
+            return https_1.request;
+    }
+    throw new Error(`Unsupported protocol: ${protocol}`);
+}
+const BASE64_SUFFIX = ';base64';
+function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || 'href' in info) {
+        const ponyfillRequest = new Request_js_1.PonyfillRequest(info, init);
+        return fetchPonyfill(ponyfillRequest);
+    }
+    const fetchRequest = info;
+    return new Promise((resolve, reject) => {
+        try {
+            const url = new URL_js_1.PonyfillURL(fetchRequest.url, 'http://localhost');
+            if (url.protocol === 'data:') {
+                const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
+                const data = decodeURIComponent(datas.join(','));
+                if (mimeType.endsWith(BASE64_SUFFIX)) {
+                    const buffer = Buffer.from(data, 'base64url');
+                    const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
+                    const file = new Blob_js_1.PonyfillBlob([buffer], { type: realMimeType });
+                    const response = new Response_js_1.PonyfillResponse(file, {
+                        status: 200,
+                        statusText: 'OK',
+                    });
+                    resolve(response);
+                    return;
+                }
+                const response = new Response_js_1.PonyfillResponse(data, {
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {
+                        'content-type': mimeType,
+                    },
+                });
+                resolve(response);
+                return;
+            }
+            if (url.protocol === 'file:') {
+                const response = getResponseForFile(fetchRequest.url);
+                resolve(response);
+                return;
+            }
+            const requestFn = getRequestFnForProtocol(url.protocol);
+            const nodeReadable = (fetchRequest.body != null
+                ? 'pipe' in fetchRequest.body
+                    ? fetchRequest.body
+                    : stream_1.Readable.from(fetchRequest.body)
+                : null);
+            const nodeHeaders = (0, utils_js_1.getHeadersObj)(fetchRequest.headers);
+            const abortListener = function abortListener(event) {
+                nodeRequest.destroy();
+                const reason = event.detail;
+                reject(new AbortError_js_1.PonyfillAbortError(reason));
+            };
+            fetchRequest.signal.addEventListener('abort', abortListener);
+            const nodeRequest = requestFn(fetchRequest.url, {
+                // signal: fetchRequest.signal will be added when v14 reaches EOL
+                method: fetchRequest.method,
+                headers: nodeHeaders,
+            });
+            nodeRequest.once('response', nodeResponse => {
+                let responseBody = nodeResponse;
+                const contentEncoding = nodeResponse.headers['content-encoding'];
+                switch (contentEncoding) {
+                    case 'x-gzip':
+                    case 'gzip':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createGunzip)());
+                        break;
+                    case 'x-deflate':
+                    case 'deflate':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createInflate)());
+                        break;
+                    case 'br':
+                        responseBody = nodeResponse.pipe((0, zlib_1.createBrotliDecompress)());
+                        break;
+                }
+                if (nodeResponse.headers.location) {
+                    if (fetchRequest.redirect === 'error') {
+                        const redirectError = new Error('Redirects are not allowed');
+                        reject(redirectError);
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        const redirectedUrl = new URL_js_1.PonyfillURL(nodeResponse.headers.location, url);
+                        const redirectResponse$ = fetchPonyfill(redirectedUrl, info);
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                const responseHeaders = nodeResponse.headers;
+                const ponyfillResponse = new Response_js_1.PonyfillResponse(responseBody, {
+                    status: nodeResponse.statusCode,
+                    statusText: nodeResponse.statusMessage,
+                    headers: responseHeaders,
+                    url: info.url,
+                });
+                resolve(ponyfillResponse);
+            });
+            nodeRequest.once('error', reject);
+            if (nodeReadable) {
+                nodeReadable.pipe(nodeRequest);
+            }
+            else {
+                nodeRequest.end();
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.fetchPonyfill = fetchPonyfill;

package/cjs/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLSearchParams = exports.URL = exports.btoa = exports.TextDecoder = exports.TextEncoder = exports.Blob = exports.AbortError = exports.AbortSignal = exports.AbortController = exports.FormData = exports.File = exports.ReadableStream = exports.Response = exports.Request = exports.Body = exports.Headers = exports.fetch = void 0;
+var fetch_js_1 = require("./fetch.js");
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_js_1.fetchPonyfill; } });
+var Headers_js_1 = require("./Headers.js");
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return Headers_js_1.PonyfillHeaders; } });
+var Body_js_1 = require("./Body.js");
+Object.defineProperty(exports, "Body", { enumerable: true, get: function () { return Body_js_1.PonyfillBody; } });
+var Request_js_1 = require("./Request.js");
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return Request_js_1.PonyfillRequest; } });
+var Response_js_1 = require("./Response.js");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return Response_js_1.PonyfillResponse; } });
+var ReadableStream_js_1 = require("./ReadableStream.js");
+Object.defineProperty(exports, "ReadableStream", { enumerable: true, get: function () { return ReadableStream_js_1.PonyfillReadableStream; } });
+var File_js_1 = require("./File.js");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return File_js_1.PonyfillFile; } });
+var FormData_js_1 = require("./FormData.js");
+Object.defineProperty(exports, "FormData", { enumerable: true, get: function () { return FormData_js_1.PonyfillFormData; } });
+var AbortController_js_1 = require("./AbortController.js");
+Object.defineProperty(exports, "AbortController", { enumerable: true, get: function () { return AbortController_js_1.PonyfillAbortController; } });
+var AbortSignal_js_1 = require("./AbortSignal.js");
+Object.defineProperty(exports, "AbortSignal", { enumerable: true, get: function () { return AbortSignal_js_1.PonyfillAbortSignal; } });
+var AbortError_js_1 = require("./AbortError.js");
+Object.defineProperty(exports, "AbortError", { enumerable: true, get: function () { return AbortError_js_1.PonyfillAbortError; } });
+var Blob_js_1 = require("./Blob.js");
+Object.defineProperty(exports, "Blob", { enumerable: true, get: function () { return Blob_js_1.PonyfillBlob; } });
+var TextEncoderDecoder_js_1 = require("./TextEncoderDecoder.js");
+Object.defineProperty(exports, "TextEncoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextEncoder; } });
+Object.defineProperty(exports, "TextDecoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextDecoder; } });
+Object.defineProperty(exports, "btoa", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillBtoa; } });
+var URL_js_1 = require("./URL.js");
+Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return URL_js_1.PonyfillURL; } });
+var URLSearchParams_js_1 = require("./URLSearchParams.js");
+Object.defineProperty(exports, "URLSearchParams", { enumerable: true, get: function () { return URLSearchParams_js_1.PonyfillURLSearchParams; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint8ArrayToArrayBuffer = exports.getHeadersObj = void 0;
+function getHeadersObj(headers) {
+    if (headers == null || !('forEach' in headers)) {
+        return headers;
+    }
+    const obj = {};
+    headers.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+exports.getHeadersObj = getHeadersObj;
+function uint8ArrayToArrayBuffer(uint8array) {
+    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
+}
+exports.uint8ArrayToArrayBuffer = uint8ArrayToArrayBuffer;

package/esm/AbortController.js

@@ -0,0 +1,10 @@
+import { PonyfillAbortSignal } from './AbortSignal.js';
+// Will be removed after v14 reaches EOL
+export class PonyfillAbortController {
+    constructor() {
+        this.signal = new PonyfillAbortSignal();
+    }
+    abort(reason) {
+        this.signal.abort(reason);
+    }
+}

package/esm/AbortError.js

@@ -0,0 +1,16 @@
+// Will be removed after v14 reaches EOL
+export class PonyfillAbortError extends Error {
+    constructor(reason) {
+        let message = 'The operation was aborted.';
+        if (reason) {
+            message += ` reason: ${reason}`;
+        }
+        super(message, {
+            cause: reason,
+        });
+        this.name = 'AbortError';
+    }
+    get reason() {
+        return this.cause;
+    }
+}

package/esm/AbortSignal.js

@@ -0,0 +1,33 @@
+// Will be removed after v14 reaches EOL
+import { CustomEvent, EventTarget } from '@whatwg-node/events';
+import { PonyfillAbortError } from './AbortError.js';
+export class PonyfillAbortSignal extends EventTarget {
+    constructor() {
+        super(...arguments);
+        this.aborted = false;
+        this._onabort = null;
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw new PonyfillAbortError();
+        }
+    }
+    get onabort() {
+        return this._onabort;
+    }
+    set onabort(value) {
+        if (this._onabort) {
+            this.removeEventListener('abort', this._onabort);
+        }
+        this.addEventListener('abort', value);
+    }
+    abort(reason) {
+        const abortEvent = new CustomEvent('abort', { detail: reason });
+        this.dispatchEvent(abortEvent);
+    }
+    static timeout(milliseconds) {
+        const signal = new PonyfillAbortSignal();
+        setTimeout(() => signal.abort(`timeout in ${milliseconds} ms`), milliseconds);
+        return signal;
+    }
+}

package/esm/Blob.js

@@ -0,0 +1,115 @@
+import { PonyfillReadableStream } from './ReadableStream.js';
+import { uint8ArrayToArrayBuffer } from './utils.js';
+function getBlobPartAsBuffer(blobPart) {
+    if (typeof blobPart === 'string') {
+        return Buffer.from(blobPart);
+    }
+    else if (Buffer.isBuffer(blobPart)) {
+        return blobPart;
+    }
+    else if (blobPart instanceof Uint8Array) {
+        return Buffer.from(blobPart);
+    }
+    else if ('buffer' in blobPart) {
+        return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+    }
+    else {
+        return Buffer.from(blobPart);
+    }
+}
+function isBlob(obj) {
+    return obj != null && typeof obj === 'object' && obj.arrayBuffer != null;
+}
+// Will be removed after v14 reaches EOL
+// Needed because v14 doesn't have .stream() implemented
+export class PonyfillBlob {
+    constructor(blobParts, options) {
+        this.blobParts = blobParts;
+        this.type = (options === null || options === void 0 ? void 0 : options.type) || 'application/octet-stream';
+        this.encoding = (options === null || options === void 0 ? void 0 : options.encoding) || 'utf8';
+    }
+    async buffer() {
+        const bufferChunks = [];
+        for (const blobPart of this.blobParts) {
+            if (isBlob(blobPart)) {
+                const arrayBuf = await blobPart.arrayBuffer();
+                const buf = Buffer.from(arrayBuf, undefined, blobPart.size);
+                bufferChunks.push(buf);
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                bufferChunks.push(buf);
+            }
+        }
+        return Buffer.concat(bufferChunks);
+    }
+    async arrayBuffer() {
+        const buffer = await this.buffer();
+        return uint8ArrayToArrayBuffer(buffer);
+    }
+    async text() {
+        let text = '';
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                text += blobPart;
+            }
+            else if ('text' in blobPart) {
+                text += await blobPart.text();
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                text += buf.toString(this.encoding);
+            }
+        }
+        return text;
+    }
+    get size() {
+        let size = 0;
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                size += Buffer.byteLength(blobPart);
+            }
+            else if (isBlob(blobPart)) {
+                size += blobPart.size;
+            }
+            else if ('length' in blobPart) {
+                size += blobPart.length;
+            }
+            else if ('byteLength' in blobPart) {
+                size += blobPart.byteLength;
+            }
+        }
+        return size;
+    }
+    stream() {
+        let partQueue = [];
+        return new PonyfillReadableStream({
+            start: controller => {
+                partQueue = [...this.blobParts];
+                if (partQueue.length === 0) {
+                    controller.close();
+                }
+            },
+            pull: async (controller) => {
+                const blobPart = partQueue.pop();
+                if (blobPart) {
+                    if (isBlob(blobPart)) {
+                        const arrayBuffer = await blobPart.arrayBuffer();
+                        const buf = Buffer.from(arrayBuffer, undefined, blobPart.size);
+                        controller.enqueue(buf);
+                    }
+                    else {
+                        const buf = getBlobPartAsBuffer(blobPart);
+                        controller.enqueue(buf);
+                    }
+                }
+                else {
+                    controller.close();
+                }
+            },
+        });
+    }
+    slice() {
+        throw new Error('Not implemented');
+    }
+}