@whatwg-node/node-fetch 0.5.0-alpha-20230710180612-32e574f → 0.5.0-alpha-20231025080723-49677d8

package/cjs/fetch.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchPonyfill = void 0;
 const fs_1 = require("fs");
 const url_1 = require("url");
-const Blob_js_1 = require("./Blob.js");
 const fetchCurl_js_1 = require("./fetchCurl.js");
 const fetchNodeHttp_js_1 = require("./fetchNodeHttp.js");
 const Request_js_1 = require("./Request.js");
 const Response_js_1 = require("./Response.js");
+const utils_js_1 = require("./utils.js");
 const BASE64_SUFFIX = ';base64';
 function getResponseForFile(url) {
     const path = (0, url_1.fileURLToPath)(url);
@@ -15,15 +15,17 @@ function getResponseForFile(url) {
     return new Response_js_1.PonyfillResponse(readable);
 }
 function getResponseForDataUri(url) {
-    const [mimeType = 'text/plain', ...datas] = url.split(',');
+    const [mimeType = 'text/plain', ...datas] = url.substring(5).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 });
-        return new Response_js_1.PonyfillResponse(file, {
+        return new Response_js_1.PonyfillResponse(buffer, {
             status: 200,
             statusText: 'OK',
+            headers: {
+                'content-type': realMimeType,
+            },
         });
     }
     return new Response_js_1.PonyfillResponse(data, {
@@ -34,19 +36,22 @@ function getResponseForDataUri(url) {
         },
     });
 }
-async function fetchPonyfill(info, init) {
-    if (typeof info === 'string' || 'href' in info) {
+function isURL(obj) {
+    return obj != null && obj.href != null;
+}
+function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || isURL(info)) {
         const ponyfillRequest = new Request_js_1.PonyfillRequest(info, init);
         return fetchPonyfill(ponyfillRequest);
     }
     const fetchRequest = info;
     if (fetchRequest.url.startsWith('data:')) {
         const response = getResponseForDataUri(fetchRequest.url);
-        return Promise.resolve(response);
+        return (0, utils_js_1.fakePromise)(response);
     }
     if (fetchRequest.url.startsWith('file:')) {
         const response = getResponseForFile(fetchRequest.url);
-        return Promise.resolve(response);
+        return (0, utils_js_1.fakePromise)(response);
     }
     if (globalThis.libcurl) {
         return (0, fetchCurl_js_1.fetchCurl)(fetchRequest);

package/cjs/fetchCurl.js

@@ -1,79 +1,106 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchCurl = void 0;
-/* eslint-disable @typescript-eslint/no-this-alias */
-const stream_1 = require("stream");
-const Headers_js_1 = require("./Headers.js");
+const node_stream_1 = require("node:stream");
+const AbortError_js_1 = require("./AbortError.js");
 const Response_js_1 = require("./Response.js");
 const utils_js_1 = require("./utils.js");
-async function fetchCurl(fetchRequest) {
-    const nodeReadable = (fetchRequest.body != null
-        ? 'pipe' in fetchRequest.body
-            ? fetchRequest.body
-            : stream_1.Readable.from(fetchRequest.body)
-        : null);
+function fetchCurl(fetchRequest) {
+    const { Curl, CurlCode, CurlFeature, CurlPause, CurlProgressFunc } = globalThis['libcurl'];
+    const curlHandle = new Curl();
+    curlHandle.enable(CurlFeature.NoDataParsing);
+    curlHandle.setOpt('URL', fetchRequest.url);
+    curlHandle.setOpt('SSL_VERIFYPEER', false);
+    curlHandle.enable(CurlFeature.StreamResponse);
+    curlHandle.setStreamProgressCallback(function () {
+        return fetchRequest['_signal']?.aborted
+            ? process.env.DEBUG
+                ? CurlProgressFunc.Continue
+                : 1
+            : 0;
+    });
+    if (fetchRequest['bodyType'] === 'String') {
+        curlHandle.setOpt('POSTFIELDS', fetchRequest['bodyInit']);
+    }
+    else {
+        const nodeReadable = (fetchRequest.body != null
+            ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
+                ? fetchRequest.body
+                : node_stream_1.Readable.from(fetchRequest.body)
+            : null);
+        if (nodeReadable) {
+            curlHandle.setOpt('UPLOAD', true);
+            curlHandle.setUploadStream(nodeReadable);
+        }
+    }
+    if (process.env.DEBUG) {
+        curlHandle.setOpt('VERBOSE', true);
+    }
+    curlHandle.setOpt('TRANSFER_ENCODING', false);
+    curlHandle.setOpt('HTTP_TRANSFER_DECODING', true);
+    curlHandle.setOpt('FOLLOWLOCATION', fetchRequest.redirect === 'follow');
+    curlHandle.setOpt('MAXREDIRS', 20);
+    curlHandle.setOpt('ACCEPT_ENCODING', '');
+    curlHandle.setOpt('CUSTOMREQUEST', fetchRequest.method);
     const headersSerializer = fetchRequest.headersSerializer || utils_js_1.defaultHeadersSerializer;
     let size;
-    const curlyHeaders = headersSerializer(fetchRequest.headers, value => {
+    const curlHeaders = headersSerializer(fetchRequest.headers, value => {
         size = Number(value);
     });
-    let easyNativeBinding;
-    const curlyOptions = {
-        // we want the unparsed binary response to be returned as a stream to us
-        curlyStreamResponse: true,
-        curlyResponseBodyParser: false,
-        curlyProgressCallback() {
-            if (easyNativeBinding == null) {
-                easyNativeBinding = this;
-            }
-            return fetchRequest.signal.aborted ? 1 : 0;
-        },
-        upload: nodeReadable != null,
-        transferEncoding: false,
-        httpTransferDecoding: true,
-        followLocation: fetchRequest.redirect === 'follow',
-        maxRedirs: 20,
-        acceptEncoding: '',
-        curlyStreamUpload: nodeReadable,
-        // this will just make libcurl use their own progress function (which is pretty neat)
-        // curlyProgressCallback() { return CurlProgressFunc.Continue },
-        // verbose: true,
-        httpHeader: curlyHeaders,
-        customRequest: fetchRequest.method,
-    };
     if (size != null) {
-        curlyOptions.inFileSize = size;
+        curlHandle.setOpt('INFILESIZE', size);
     }
-    const { curly, CurlCode, CurlPause } = globalThis['libcurl'];
-    fetchRequest.signal.onabort = () => {
-        if (easyNativeBinding != null) {
-            easyNativeBinding.pause(CurlPause.Recv);
+    curlHandle.setOpt('HTTPHEADER', curlHeaders);
+    curlHandle.enable(CurlFeature.NoHeaderParsing);
+    return new Promise(function promiseResolver(resolve, reject) {
+        let streamResolved = false;
+        if (fetchRequest['_signal']) {
+            fetchRequest['_signal'].onabort = () => {
+                if (streamResolved) {
+                    curlHandle.pause(CurlPause.Recv);
+                }
+                else {
+                    reject(new AbortError_js_1.PonyfillAbortError());
+                    curlHandle.close();
+                }
+            };
         }
-    };
-    const curlyResult = await curly(fetchRequest.url, curlyOptions);
-    const responseHeaders = new Headers_js_1.PonyfillHeaders();
-    curlyResult.headers.forEach(headerInfo => {
-        for (const key in headerInfo) {
-            if (key === 'location' || (key === 'Location' && fetchRequest.redirect === 'error')) {
-                throw new Error('redirects are not allowed');
+        curlHandle.once('end', function endListener() {
+            curlHandle.close();
+        });
+        curlHandle.once('error', function errorListener(error) {
+            if (error.isCurlError && error.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
+                // this is expected
             }
-            if (key !== 'result') {
-                responseHeaders.append(key, headerInfo[key]);
+            else {
+                // this is unexpected
+                reject(error);
             }
-        }
-    });
-    curlyResult.data.on('error', (err) => {
-        if (err.isCurlError && err.code === CurlCode.CURLE_ABORTED_BY_CALLBACK) {
-            // this is expected
-        }
-        else {
-            throw err;
-        }
-    });
-    return new Response_js_1.PonyfillResponse(curlyResult.data, {
-        status: curlyResult.statusCode,
-        headers: responseHeaders,
-        url: fetchRequest.url,
+            curlHandle.close();
+        });
+        curlHandle.once('stream', function streamListener(stream, status, headersBuf) {
+            const headersFlat = headersBuf
+                .toString('utf8')
+                .split(/\r?\n|\r/g)
+                .filter(headerFilter => {
+                if (headerFilter && !headerFilter.startsWith('HTTP/')) {
+                    if (fetchRequest.redirect === 'error' &&
+                        (headerFilter.includes('location') || headerFilter.includes('Location'))) {
+                        reject(new Error('redirect is not allowed'));
+                    }
+                    return true;
+                }
+                return false;
+            });
+            const headersInit = headersFlat.map(headerFlat => headerFlat.split(/:\s(.+)/).slice(0, 2));
+            resolve(new Response_js_1.PonyfillResponse(stream, {
+                status,
+                headers: headersInit,
+                url: fetchRequest.url,
+            }));
+            streamResolved = true;
+        });
+        curlHandle.perform();
     });
 }
 exports.fetchCurl = fetchCurl;

package/cjs/fetchNodeHttp.js

@@ -5,7 +5,6 @@ const http_1 = require("http");
 const https_1 = require("https");
 const stream_1 = require("stream");
 const zlib_1 = require("zlib");
-const AbortError_js_1 = require("./AbortError.js");
 const Request_js_1 = require("./Request.js");
 const Response_js_1 = require("./Response.js");
 const URL_js_1 = require("./URL.js");
@@ -24,7 +23,7 @@ function fetchNodeHttp(fetchRequest) {
         try {
             const requestFn = getRequestFnForProtocol(fetchRequest.url);
             const nodeReadable = (fetchRequest.body != null
-                ? 'pipe' in fetchRequest.body
+                ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
                     ? fetchRequest.body
                     : stream_1.Readable.from(fetchRequest.body)
                 : null);
@@ -33,19 +32,9 @@ function fetchNodeHttp(fetchRequest) {
             const nodeRequest = requestFn(fetchRequest.url, {
                 method: fetchRequest.method,
                 headers: nodeHeaders,
-                signal: fetchRequest.signal,
+                signal: fetchRequest['_signal'] ?? undefined,
                 agent: fetchRequest.agent,
             });
-            // TODO: will be removed after v16 reaches EOL
-            fetchRequest.signal?.addEventListener('abort', () => {
-                if (!nodeRequest.aborted) {
-                    nodeRequest.abort();
-                }
-            });
-            // TODO: will be removed after v16 reaches EOL
-            nodeRequest.once('abort', (reason) => {
-                reject(new AbortError_js_1.PonyfillAbortError(reason));
-            });
             nodeRequest.once('response', nodeResponse => {
                 let responseBody = nodeResponse;
                 const contentEncoding = nodeResponse.headers['content-encoding'];

package/cjs/utils.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultHeadersSerializer = exports.uint8ArrayToArrayBuffer = exports.getHeadersObj = void 0;
+exports.isNodeReadable = exports.isArrayBufferView = exports.fakePromise = exports.defaultHeadersSerializer = exports.getHeadersObj = void 0;
+function isHeadersInstance(obj) {
+    return obj?.forEach != null;
+}
 function getHeadersObj(headers) {
-    if (headers == null || !('forEach' in headers)) {
+    if (headers == null || !isHeadersInstance(headers)) {
         return headers;
     }
     const obj = {};
@@ -12,10 +15,6 @@ function getHeadersObj(headers) {
     return obj;
 }
 exports.getHeadersObj = getHeadersObj;
-function uint8ArrayToArrayBuffer(uint8array) {
-    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
-}
-exports.uint8ArrayToArrayBuffer = uint8ArrayToArrayBuffer;
 function defaultHeadersSerializer(headers, onContentLength) {
     const headerArray = [];
     headers.forEach((value, key) => {
@@ -27,3 +26,48 @@ function defaultHeadersSerializer(headers, onContentLength) {
     return headerArray;
 }
 exports.defaultHeadersSerializer = defaultHeadersSerializer;
+function isPromise(val) {
+    return val?.then != null;
+}
+function fakePromise(value) {
+    if (isPromise(value)) {
+        return value;
+    }
+    // Write a fake promise to avoid the promise constructor
+    // being called with `new Promise` in the browser.
+    return {
+        then(resolve) {
+            if (resolve) {
+                const callbackResult = resolve(value);
+                if (isPromise(callbackResult)) {
+                    return callbackResult;
+                }
+                return fakePromise(callbackResult);
+            }
+            return this;
+        },
+        catch() {
+            return this;
+        },
+        finally(cb) {
+            if (cb) {
+                const callbackResult = cb();
+                if (isPromise(callbackResult)) {
+                    return callbackResult.then(() => value);
+                }
+                return fakePromise(value);
+            }
+            return this;
+        },
+        [Symbol.toStringTag]: 'Promise',
+    };
+}
+exports.fakePromise = fakePromise;
+function isArrayBufferView(obj) {
+    return obj != null && obj.buffer != null && obj.byteLength != null && obj.byteOffset != null;
+}
+exports.isArrayBufferView = isArrayBufferView;
+function isNodeReadable(obj) {
+    return obj != null && obj.pipe != null;
+}
+exports.isNodeReadable = isNodeReadable;

package/esm/Blob.js

@@ -1,5 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 import { PonyfillReadableStream } from './ReadableStream.js';
-import { uint8ArrayToArrayBuffer } from './utils.js';
+import { fakePromise, isArrayBufferView } from './utils.js';
 function getBlobPartAsBuffer(blobPart) {
     if (typeof blobPart === 'string') {
         return Buffer.from(blobPart);
@@ -7,10 +8,7 @@ function getBlobPartAsBuffer(blobPart) {
     else if (Buffer.isBuffer(blobPart)) {
         return blobPart;
     }
-    else if (blobPart instanceof Uint8Array) {
-        return Buffer.from(blobPart);
-    }
-    else if ('buffer' in blobPart) {
+    else if (isArrayBufferView(blobPart)) {
         return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
     }
     else {
@@ -18,93 +16,115 @@ function getBlobPartAsBuffer(blobPart) {
     }
 }
 function isBlob(obj) {
-    return obj != null && typeof obj === 'object' && obj.arrayBuffer != null;
+    return obj != null && 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._size = null;
         this.type = options?.type || 'application/octet-stream';
         this.encoding = options?.encoding || 'utf8';
+        this._size = options?.size || null;
+        if (blobParts.length === 1 && isBlob(blobParts[0])) {
+            return blobParts[0];
+        }
     }
-    async buffer() {
-        const bufferChunks = [];
-        for (const blobPart of this.blobParts) {
+    arrayBuffer() {
+        if (this.blobParts.length === 1) {
+            const blobPart = this.blobParts[0];
             if (isBlob(blobPart)) {
-                const arrayBuf = await blobPart.arrayBuffer();
-                const buf = Buffer.from(arrayBuf, undefined, blobPart.size);
-                bufferChunks.push(buf);
+                return blobPart.arrayBuffer();
+            }
+            return fakePromise(getBlobPartAsBuffer(blobPart));
+        }
+        const jobs = [];
+        const bufferChunks = this.blobParts.map((blobPart, i) => {
+            if (isBlob(blobPart)) {
+                jobs.push(blobPart.arrayBuffer().then(arrayBuf => {
+                    bufferChunks[i] = Buffer.from(arrayBuf, undefined, blobPart.size);
+                }));
+                return undefined;
             }
             else {
-                const buf = getBlobPartAsBuffer(blobPart);
-                bufferChunks.push(buf);
+                return getBlobPartAsBuffer(blobPart);
             }
+        });
+        if (jobs.length > 0) {
+            return Promise.all(jobs).then(() => Buffer.concat(bufferChunks, this._size || undefined));
         }
-        return Buffer.concat(bufferChunks);
+        return fakePromise(Buffer.concat(bufferChunks, this._size || undefined));
     }
-    async arrayBuffer() {
-        const buffer = await this.buffer();
-        return uint8ArrayToArrayBuffer(buffer);
-    }
-    async text() {
-        let text = '';
-        for (const blobPart of this.blobParts) {
+    text() {
+        if (this.blobParts.length === 1) {
+            const blobPart = this.blobParts[0];
             if (typeof blobPart === 'string') {
-                text += blobPart;
-            }
-            else if ('text' in blobPart) {
-                text += await blobPart.text();
+                return fakePromise(blobPart);
             }
-            else {
-                const buf = getBlobPartAsBuffer(blobPart);
-                text += buf.toString(this.encoding);
+            if (isBlob(blobPart)) {
+                return blobPart.text();
             }
+            const buf = getBlobPartAsBuffer(blobPart);
+            return fakePromise(buf.toString(this.encoding));
         }
-        return text;
+        return this.arrayBuffer().then(buf => buf.toString(this.encoding));
     }
     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;
+        if (this._size == null) {
+            this._size = 0;
+            for (const blobPart of this.blobParts) {
+                if (typeof blobPart === 'string') {
+                    this._size += Buffer.byteLength(blobPart);
+                }
+                else if (isBlob(blobPart)) {
+                    this._size += blobPart.size;
+                }
+                else if (isArrayBufferView(blobPart)) {
+                    this._size += blobPart.byteLength;
+                }
             }
         }
-        return size;
+        return this._size;
     }
     stream() {
-        let partQueue = [];
+        if (this.blobParts.length === 1) {
+            const blobPart = this.blobParts[0];
+            if (isBlob(blobPart)) {
+                return blobPart.stream();
+            }
+            const buf = getBlobPartAsBuffer(blobPart);
+            return new PonyfillReadableStream({
+                start: controller => {
+                    controller.enqueue(buf);
+                    controller.close();
+                },
+            });
+        }
+        let blobPartIterator;
         return new PonyfillReadableStream({
             start: controller => {
-                partQueue = [...this.blobParts];
-                if (partQueue.length === 0) {
+                if (this.blobParts.length === 0) {
                     controller.close();
+                    return;
                 }
+                blobPartIterator = this.blobParts[Symbol.iterator]();
             },
-            pull: async (controller) => {
-                const blobPart = partQueue.pop();
+            pull: controller => {
+                const { value: blobPart, done } = blobPartIterator.next();
+                if (done) {
+                    controller.close();
+                    return;
+                }
                 if (blobPart) {
                     if (isBlob(blobPart)) {
-                        const arrayBuffer = await blobPart.arrayBuffer();
-                        const buf = Buffer.from(arrayBuffer, undefined, blobPart.size);
-                        controller.enqueue(buf);
+                        return blobPart.arrayBuffer().then(arrayBuffer => {
+                            const buf = Buffer.from(arrayBuffer, undefined, blobPart.size);
+                            controller.enqueue(buf);
+                        });
                     }
-                    else {
-                        const buf = getBlobPartAsBuffer(blobPart);
-                        controller.enqueue(buf);
-                    }
-                }
-                else {
-                    controller.close();
+                    const buf = getBlobPartAsBuffer(blobPart);
+                    controller.enqueue(buf);
                 }
             },
         });