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

package/cjs/Blob.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillBlob = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
 const ReadableStream_js_1 = require("./ReadableStream.js");
 const utils_js_1 = require("./utils.js");
 function getBlobPartAsBuffer(blobPart) {
@@ -10,10 +11,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 ((0, utils_js_1.isArrayBufferView)(blobPart)) {
         return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
     }
     else {
@@ -21,93 +19,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
 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 (0, utils_js_1.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 (0, utils_js_1.fakePromise)(Buffer.concat(bufferChunks, this._size || undefined));
     }
-    async arrayBuffer() {
-        const buffer = await this.buffer();
-        return (0, utils_js_1.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 (0, utils_js_1.fakePromise)(blobPart);
             }
-            else {
-                const buf = getBlobPartAsBuffer(blobPart);
-                text += buf.toString(this.encoding);
+            if (isBlob(blobPart)) {
+                return blobPart.text();
             }
+            const buf = getBlobPartAsBuffer(blobPart);
+            return (0, utils_js_1.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 ((0, utils_js_1.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 ReadableStream_js_1.PonyfillReadableStream({
+                start: controller => {
+                    controller.enqueue(buf);
+                    controller.close();
+                },
+            });
+        }
+        let blobPartIterator;
         return new ReadableStream_js_1.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);
                 }
             },
         });

package/cjs/Body.js

@@ -14,11 +14,9 @@ var BodyInitType;
     BodyInitType["ReadableStream"] = "ReadableStream";
     BodyInitType["Blob"] = "Blob";
     BodyInitType["FormData"] = "FormData";
-    BodyInitType["ArrayBuffer"] = "ArrayBuffer";
     BodyInitType["String"] = "String";
     BodyInitType["Readable"] = "Readable";
     BodyInitType["Buffer"] = "Buffer";
-    BodyInitType["Uint8Array"] = "Uint8Array";
 })(BodyInitType || (BodyInitType = {}));
 class PonyfillBody {
     constructor(bodyInit, options = {}) {
@@ -29,11 +27,12 @@ class PonyfillBody {
         this.contentLength = null;
         this._bodyFactory = () => null;
         this._generatedBody = null;
-        const { bodyFactory, contentType, contentLength, bodyType } = processBodyInit(bodyInit);
+        const { bodyFactory, contentType, contentLength, bodyType, buffer } = processBodyInit(bodyInit);
         this._bodyFactory = bodyFactory;
         this.contentType = contentType;
         this.contentLength = contentLength;
         this.bodyType = bodyType;
+        this._buffer = buffer;
     }
     generateBody() {
         if (this._generatedBody) {
@@ -69,68 +68,50 @@ class PonyfillBody {
         }
         return null;
     }
-    async arrayBuffer() {
-        if (this.bodyType === BodyInitType.ArrayBuffer) {
-            return this.bodyInit;
-        }
-        if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.Buffer) {
-            const typedBodyInit = this.bodyInit;
-            return (0, utils_js_1.uint8ArrayToArrayBuffer)(typedBodyInit);
-        }
-        if (this.bodyType === BodyInitType.String) {
-            const buffer = Buffer.from(this.bodyInit);
-            return (0, utils_js_1.uint8ArrayToArrayBuffer)(buffer);
-        }
-        if (this.bodyType === BodyInitType.Blob) {
-            const blob = this.bodyInit;
-            const arrayBuffer = await blob.arrayBuffer();
-            return arrayBuffer;
-        }
-        const blob = await this.blob();
-        return blob.arrayBuffer();
-    }
-    async _collectChunksFromReadable() {
-        const chunks = [];
+    _collectChunksFromReadable() {
         const _body = this.generateBody();
-        if (_body) {
-            for await (const chunk of _body.readable) {
-                chunks.push(chunk);
-            }
+        if (!_body) {
+            return (0, utils_js_1.fakePromise)([]);
         }
-        return chunks;
+        const chunks = [];
+        _body.readable.on('data', chunk => {
+            chunks.push(chunk);
+        });
+        return new Promise((resolve, reject) => {
+            _body.readable.once('end', () => {
+                resolve(chunks);
+            });
+            _body.readable.once('error', e => {
+                reject(e);
+            });
+        });
     }
-    async blob() {
+    blob() {
         if (this.bodyType === BodyInitType.Blob) {
-            return this.bodyInit;
+            return (0, utils_js_1.fakePromise)(this.bodyInit);
         }
-        if (this.bodyType === BodyInitType.String ||
-            this.bodyType === BodyInitType.Buffer ||
-            this.bodyType === BodyInitType.Uint8Array) {
-            const bodyInitTyped = this.bodyInit;
-            return new Blob_js_1.PonyfillBlob([bodyInitTyped], {
+        if (this._buffer) {
+            const blob = new Blob_js_1.PonyfillBlob([this._buffer], {
                 type: this.contentType || '',
+                size: this.contentLength,
             });
+            return (0, utils_js_1.fakePromise)(blob);
         }
-        if (this.bodyType === BodyInitType.ArrayBuffer) {
-            const bodyInitTyped = this.bodyInit;
-            const buf = Buffer.from(bodyInitTyped, undefined, bodyInitTyped.byteLength);
-            return new Blob_js_1.PonyfillBlob([buf], {
+        return this._collectChunksFromReadable().then(chunks => {
+            return new Blob_js_1.PonyfillBlob(chunks, {
                 type: this.contentType || '',
+                size: this.contentLength,
             });
-        }
-        const chunks = await this._collectChunksFromReadable();
-        return new Blob_js_1.PonyfillBlob(chunks, {
-            type: this.contentType || '',
         });
     }
     formData(opts) {
         if (this.bodyType === BodyInitType.FormData) {
-            return Promise.resolve(this.bodyInit);
+            return (0, utils_js_1.fakePromise)(this.bodyInit);
         }
         const formData = new FormData_js_1.PonyfillFormData();
         const _body = this.generateBody();
         if (_body == null) {
-            return Promise.resolve(formData);
+            return (0, utils_js_1.fakePromise)(formData);
         }
         const formDataLimits = {
             ...this.options.formDataLimits,
@@ -162,7 +143,7 @@ class PonyfillBody {
                     reject(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
                 });
                 fileStream.on('data', chunk => {
-                    chunks.push(Buffer.from(chunk));
+                    chunks.push(chunk);
                 });
                 fileStream.on('close', () => {
                     if (fileStream.truncated) {
@@ -187,39 +168,36 @@ class PonyfillBody {
             _body?.readable.pipe(bb);
         });
     }
-    async buffer() {
-        if (this.bodyType === BodyInitType.Buffer) {
-            return this.bodyInit;
-        }
-        if (this.bodyType === BodyInitType.String) {
-            return Buffer.from(this.bodyInit);
-        }
-        if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.ArrayBuffer) {
-            const bodyInitTyped = this.bodyInit;
-            const buffer = Buffer.from(bodyInitTyped, 'byteOffset' in bodyInitTyped ? bodyInitTyped.byteOffset : undefined, bodyInitTyped.byteLength);
-            return buffer;
+    arrayBuffer() {
+        if (this._buffer) {
+            return (0, utils_js_1.fakePromise)(this._buffer);
         }
         if (this.bodyType === BodyInitType.Blob) {
             if (this.bodyInit instanceof Blob_js_1.PonyfillBlob) {
-                return this.bodyInit.buffer();
+                return this.bodyInit.arrayBuffer();
             }
             const bodyInitTyped = this.bodyInit;
-            const buffer = Buffer.from(await bodyInitTyped.arrayBuffer(), undefined, bodyInitTyped.size);
-            return buffer;
+            return bodyInitTyped
+                .arrayBuffer()
+                .then(arrayBuffer => Buffer.from(arrayBuffer, undefined, bodyInitTyped.size));
         }
-        const chunks = await this._collectChunksFromReadable();
-        return Buffer.concat(chunks);
+        return this._collectChunksFromReadable().then(function concatCollectedChunksFromReadable(chunks) {
+            if (chunks.length === 1) {
+                return chunks[0];
+            }
+            return Buffer.concat(chunks);
+        });
     }
-    async json() {
-        const text = await this.text();
-        return JSON.parse(text);
+    json() {
+        return this.text().then(function parseTextAsJson(text) {
+            return JSON.parse(text);
+        });
     }
-    async text() {
+    text() {
         if (this.bodyType === BodyInitType.String) {
-            return this.bodyInit;
+            return (0, utils_js_1.fakePromise)(this.bodyInit);
         }
-        const buffer = await this.buffer();
-        return buffer.toString('utf-8');
+        return this.arrayBuffer().then(buffer => buffer.toString('utf-8'));
     }
 }
 exports.PonyfillBody = PonyfillBody;
@@ -238,18 +216,19 @@ function processBodyInit(bodyInit) {
             bodyType: BodyInitType.String,
             contentType: 'text/plain;charset=UTF-8',
             contentLength,
+            buffer,
             bodyFactory() {
                 const readable = stream_1.Readable.from(buffer);
                 return new ReadableStream_js_1.PonyfillReadableStream(readable);
             },
         };
     }
-    if (bodyInit instanceof Buffer) {
-        const contentLength = bodyInit.byteLength;
+    if (Buffer.isBuffer(bodyInit)) {
         return {
             bodyType: BodyInitType.Buffer,
-            contentLength,
             contentType: null,
+            contentLength: bodyInit.length,
+            buffer: bodyInit,
             bodyFactory() {
                 const readable = stream_1.Readable.from(bodyInit);
                 const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
@@ -257,6 +236,20 @@ function processBodyInit(bodyInit) {
             },
         };
     }
+    if ((0, utils_js_1.isArrayBufferView)(bodyInit)) {
+        const buffer = Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength);
+        return {
+            bodyType: BodyInitType.Buffer,
+            contentLength: bodyInit.byteLength,
+            contentType: null,
+            buffer,
+            bodyFactory() {
+                const readable = stream_1.Readable.from(buffer);
+                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
     if (bodyInit instanceof ReadableStream_js_1.PonyfillReadableStream) {
         return {
             bodyType: BodyInitType.ReadableStream,
@@ -265,7 +258,7 @@ function processBodyInit(bodyInit) {
             contentLength: null,
         };
     }
-    if (bodyInit instanceof Blob_js_1.PonyfillBlob) {
+    if (isBlob(bodyInit)) {
         return {
             bodyType: BodyInitType.Blob,
             contentType: bodyInit.type,
@@ -275,40 +268,15 @@ function processBodyInit(bodyInit) {
             },
         };
     }
-    if (bodyInit instanceof Uint8Array) {
-        const contentLength = bodyInit.byteLength;
-        return {
-            bodyType: BodyInitType.Uint8Array,
-            contentLength,
-            contentType: null,
-            bodyFactory() {
-                const readable = stream_1.Readable.from(bodyInit);
-                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
-                return body;
-            },
-        };
-    }
-    if ('buffer' in bodyInit) {
-        const contentLength = bodyInit.byteLength;
-        return {
-            contentLength,
-            contentType: null,
-            bodyFactory() {
-                const buffer = Buffer.from(bodyInit);
-                const readable = stream_1.Readable.from(buffer);
-                const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
-                return body;
-            },
-        };
-    }
     if (bodyInit instanceof ArrayBuffer) {
         const contentLength = bodyInit.byteLength;
+        const buffer = Buffer.from(bodyInit, undefined, bodyInit.byteLength);
         return {
-            bodyType: BodyInitType.ArrayBuffer,
+            bodyType: BodyInitType.Buffer,
             contentType: null,
             contentLength,
+            buffer,
             bodyFactory() {
-                const buffer = Buffer.from(bodyInit, undefined, bodyInit.byteLength);
                 const readable = stream_1.Readable.from(buffer);
                 const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
                 return body;
@@ -326,18 +294,7 @@ function processBodyInit(bodyInit) {
             },
         };
     }
-    if ('stream' in bodyInit) {
-        return {
-            contentType: bodyInit.type,
-            contentLength: bodyInit.size,
-            bodyFactory() {
-                const bodyStream = bodyInit.stream();
-                const body = new ReadableStream_js_1.PonyfillReadableStream(bodyStream);
-                return body;
-            },
-        };
-    }
-    if ('sort' in bodyInit) {
+    if (isURLSearchParams(bodyInit)) {
         const contentType = 'application/x-www-form-urlencoded;charset=UTF-8';
         return {
             bodyType: BodyInitType.String,
@@ -349,10 +306,11 @@ function processBodyInit(bodyInit) {
             },
         };
     }
-    if ('forEach' in bodyInit) {
+    if (isFormData(bodyInit)) {
         const boundary = Math.random().toString(36).substr(2);
         const contentType = `multipart/form-data; boundary=${boundary}`;
         return {
+            bodyType: BodyInitType.FormData,
             contentType,
             contentLength: null,
             bodyFactory() {
@@ -372,3 +330,12 @@ function processBodyInit(bodyInit) {
     }
     throw new Error('Unknown body type');
 }
+function isFormData(value) {
+    return value?.forEach != null;
+}
+function isBlob(value) {
+    return value?.stream != null;
+}
+function isURLSearchParams(value) {
+    return value?.sort != null;
+}

package/cjs/FormData.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStreamFromFormData = exports.PonyfillFormData = void 0;
-const File_js_1 = require("./File.js");
 const ReadableStream_js_1 = require("./ReadableStream.js");
 class PonyfillFormData {
     constructor() {
@@ -118,17 +117,9 @@ function getStreamFromFormData(formData, boundary = '---') {
 }
 exports.getStreamFromFormData = getStreamFromFormData;
 function getNormalizedFile(name, blob, fileName) {
-    if (blob instanceof File_js_1.PonyfillFile) {
-        if (fileName != null) {
-            return new File_js_1.PonyfillFile([blob], fileName, {
-                type: blob.type,
-                lastModified: blob.lastModified,
-            });
-        }
-        return blob;
-    }
-    return new File_js_1.PonyfillFile([blob], fileName || name, { type: blob.type });
+    blob.name = fileName || blob.name || name;
+    return blob;
 }
 function isBlob(value) {
-    return value != null && typeof value === 'object' && typeof value.arrayBuffer === 'function';
+    return value?.arrayBuffer != null;
 }

package/cjs/Headers.js

@@ -24,7 +24,7 @@ class PonyfillHeaders {
         }
         const normalized = key.toLowerCase();
         if (Array.isArray(this.headersInit)) {
-            return this.headersInit.find(header => header[0] === normalized)?.[1] || null;
+            return this.headersInit.find(header => header[0].toLowerCase() === normalized)?.[1] || null;
         }
         else if (isHeadersLike(this.headersInit)) {
             return this.headersInit.get(normalized);

package/cjs/ReadableStream.js

@@ -36,23 +36,29 @@ function createController(desiredSize, readable) {
         _flush() {
             flushed = true;
             if (chunks.length > 0) {
-                const concatenated = Buffer.concat(chunks);
+                const concatenated = chunks.length > 1 ? Buffer.concat(chunks) : chunks[0];
                 readable.push(concatenated);
                 chunks = [];
             }
         },
     };
 }
+function isNodeReadable(obj) {
+    return obj?.read != null;
+}
+function isReadableStream(obj) {
+    return obj?.getReader != null;
+}
 class PonyfillReadableStream {
     constructor(underlyingSource) {
         this.locked = false;
         if (underlyingSource instanceof PonyfillReadableStream) {
             this.readable = underlyingSource.readable;
         }
-        else if (underlyingSource && 'read' in underlyingSource) {
+        else if (isNodeReadable(underlyingSource)) {
             this.readable = underlyingSource;
         }
-        else if (underlyingSource && 'getReader' in underlyingSource) {
+        else if (isReadableStream(underlyingSource)) {
             let reader;
             let started = false;
             this.readable = new stream_1.Readable({
@@ -162,7 +168,7 @@ class PonyfillReadableStream {
         return readable;
     }
     static [Symbol.hasInstance](instance) {
-        return instance != null && typeof instance === 'object' && 'getReader' in instance;
+        return isReadableStream(instance);
     }
 }
 exports.PonyfillReadableStream = PonyfillReadableStream;

package/cjs/Request.js

@@ -6,6 +6,9 @@ const Headers_js_1 = require("./Headers.js");
 function isRequest(input) {
     return input[Symbol.toStringTag] === 'Request';
 }
+function isURL(obj) {
+    return obj?.href != null;
+}
 class PonyfillRequest extends Body_js_1.PonyfillBody {
     constructor(input, options) {
         let url;
@@ -14,7 +17,7 @@ class PonyfillRequest extends Body_js_1.PonyfillBody {
         if (typeof input === 'string') {
             url = input;
         }
-        else if ('href' in input) {
+        else if (isURL(input)) {
             url = input.toString();
         }
         else if (isRequest(input)) {

package/cjs/TextEncoderDecoder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillBtoa = exports.PonyfillTextDecoder = exports.PonyfillTextEncoder = void 0;
+const utils_js_1 = require("./utils.js");
 class PonyfillTextEncoder {
     constructor(encoding = 'utf-8') {
         this.encoding = encoding;
@@ -29,6 +30,12 @@ class PonyfillTextDecoder {
         }
     }
     decode(input) {
+        if (Buffer.isBuffer(input)) {
+            return input.toString(this.encoding);
+        }
+        if ((0, utils_js_1.isArrayBufferView)(input)) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
+        }
         return Buffer.from(input).toString(this.encoding);
     }
 }

package/cjs/URLSearchParams.js

@@ -3,6 +3,9 @@ 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"));
+function isURLSearchParams(value) {
+    return value?.entries != null;
+}
 class PonyfillURLSearchParams {
     constructor(init) {
         if (init) {
@@ -15,7 +18,7 @@ class PonyfillURLSearchParams {
                     this.params[key] = value;
                 }
             }
-            else if ('entries' in init) {
+            else if (isURLSearchParams(init)) {
                 this.params = {};
                 for (const [key, value] of init.entries()) {
                     this.params[key] = value;