@whatwg-node/node-fetch 0.8.0-alpha-20241212154840-0a0effe808a6614e0a3afd853126a38641485756 → 0.8.0-alpha-20250917012053-36c9ccdc3e94ee8d0961f17398a9053fa55df37b

package/cjs/AbortError.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillAbortError = void 0;
-class PonyfillAbortError extends DOMException {
+class PonyfillAbortError extends Error {
     constructor(reason) {
         let message = 'The operation was aborted';
         if (reason) {
             message += ` reason: ${reason}`;
         }
-        super(message, 'AbortError');
-        this.cause = reason;
+        super(message, {
+            cause: reason,
+        });
+        this.name = 'AbortError';
     }
     get reason() {
         return this.cause;

package/cjs/Blob.js

@@ -10,20 +10,22 @@ exports.hasStreamMethod = hasStreamMethod;
 exports.hasBlobSignature = hasBlobSignature;
 exports.isArrayBuffer = isArrayBuffer;
 /* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const node_buffer_1 = require("node:buffer");
 const ReadableStream_js_1 = require("./ReadableStream.js");
 const utils_js_1 = require("./utils.js");
 function getBlobPartAsBuffer(blobPart) {
     if (typeof blobPart === 'string') {
-        return Buffer.from(blobPart);
+        return node_buffer_1.Buffer.from(blobPart);
     }
-    else if (Buffer.isBuffer(blobPart)) {
+    else if (node_buffer_1.Buffer.isBuffer(blobPart)) {
         return blobPart;
     }
     else if ((0, utils_js_1.isArrayBufferView)(blobPart)) {
-        return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+        return node_buffer_1.Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
     }
     else {
-        return Buffer.from(blobPart);
+        return node_buffer_1.Buffer.from(blobPart);
     }
 }
 function hasBufferMethod(obj) {
@@ -81,13 +83,13 @@ class PonyfillBlob {
             }
             if (hasBytesMethod(blobPart)) {
                 return blobPart.bytes().then(bytes => {
-                    this._buffer = Buffer.from(bytes);
+                    this._buffer = node_buffer_1.Buffer.from(bytes);
                     return this._buffer;
                 });
             }
             if (hasArrayBufferMethod(blobPart)) {
                 return blobPart.arrayBuffer().then(arrayBuf => {
-                    this._buffer = Buffer.from(arrayBuf, undefined, blobPart.size);
+                    this._buffer = node_buffer_1.Buffer.from(arrayBuf, undefined, blobPart.size);
                     return this._buffer;
                 });
             }
@@ -104,13 +106,13 @@ class PonyfillBlob {
             }
             else if (hasArrayBufferMethod(blobPart)) {
                 jobs.push(blobPart.arrayBuffer().then(arrayBuf => {
-                    bufferChunks[i] = Buffer.from(arrayBuf, undefined, blobPart.size);
+                    bufferChunks[i] = node_buffer_1.Buffer.from(arrayBuf, undefined, blobPart.size);
                 }));
                 return undefined;
             }
             else if (hasBytesMethod(blobPart)) {
                 jobs.push(blobPart.bytes().then(bytes => {
-                    bufferChunks[i] = Buffer.from(bytes);
+                    bufferChunks[i] = node_buffer_1.Buffer.from(bytes);
                 }));
                 return undefined;
             }
@@ -119,13 +121,13 @@ class PonyfillBlob {
             }
         });
         if (jobs.length > 0) {
-            return Promise.all(jobs).then(() => Buffer.concat(bufferChunks, this._size || undefined));
+            return Promise.all(jobs).then(() => node_buffer_1.Buffer.concat(bufferChunks, this._size || undefined));
         }
-        return (0, utils_js_1.fakePromise)(Buffer.concat(bufferChunks, this._size || undefined));
+        return (0, utils_js_1.fakePromise)(node_buffer_1.Buffer.concat(bufferChunks, this._size || undefined));
     }
     arrayBuffer() {
         if (this._buffer) {
-            // @ts-expect-error - `Buffer` and `ArrayBuffer` are compatible
+            // @ts-ignore - Mismatch between Buffer and ArrayBuffer
             return (0, utils_js_1.fakePromise)(this._buffer);
         }
         if (this.blobParts.length === 1) {
@@ -136,7 +138,7 @@ class PonyfillBlob {
                 return this.blobParts[0].arrayBuffer();
             }
         }
-        // @ts-expect-error - `Buffer` and `ArrayBuffer` are compatible
+        // @ts-ignore - Mismatch between Buffer and ArrayBuffer
         return this.buffer();
     }
     bytes() {
@@ -144,13 +146,13 @@ class PonyfillBlob {
             return (0, utils_js_1.fakePromise)(this._buffer);
         }
         if (this.blobParts.length === 1) {
-            if (Buffer.isBuffer(this.blobParts[0])) {
+            if (node_buffer_1.Buffer.isBuffer(this.blobParts[0])) {
                 this._buffer = this.blobParts[0];
-                return (0, utils_js_1.fakePromise)(this.blobParts[0]);
+                return (0, utils_js_1.fakePromise)(this._buffer);
             }
             if (this.blobParts[0] instanceof Uint8Array) {
-                this._buffer = Buffer.from(this.blobParts[0]);
-                return (0, utils_js_1.fakePromise)(this.blobParts[0]);
+                this._buffer = node_buffer_1.Buffer.from(this.blobParts[0]);
+                return (0, utils_js_1.fakePromise)(this._buffer);
             }
             if (hasBytesMethod(this.blobParts[0])) {
                 return this.blobParts[0].bytes();
@@ -209,7 +211,7 @@ class PonyfillBlob {
             this._size = 0;
             for (const blobPart of this.blobParts) {
                 if (typeof blobPart === 'string') {
-                    this._size += Buffer.byteLength(blobPart);
+                    this._size += node_buffer_1.Buffer.byteLength(blobPart);
                 }
                 else if (hasSizeProperty(blobPart)) {
                     this._size += blobPart.size;
@@ -266,13 +268,13 @@ class PonyfillBlob {
                     }
                     if (hasBytesMethod(blobPart)) {
                         return blobPart.bytes().then(bytes => {
-                            const buf = Buffer.from(bytes);
+                            const buf = node_buffer_1.Buffer.from(bytes);
                             controller.enqueue(buf);
                         });
                     }
                     if (hasArrayBufferMethod(blobPart)) {
                         return blobPart.arrayBuffer().then(arrayBuffer => {
-                            const buf = Buffer.from(arrayBuffer, undefined, blobPart.size);
+                            const buf = node_buffer_1.Buffer.from(arrayBuffer, undefined, blobPart.size);
                             controller.enqueue(buf);
                         });
                     }

package/cjs/Body.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PonyfillBody = void 0;
-const tslib_1 = require("tslib");
-const stream_1 = require("stream");
-const busboy_1 = tslib_1.__importDefault(require("busboy"));
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const node_buffer_1 = require("node:buffer");
+const node_stream_1 = require("node:stream");
+const busboy_1 = require("@fastify/busboy");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
 const Blob_js_1 = require("./Blob.js");
 const File_js_1 = require("./File.js");
 const FormData_js_1 = require("./FormData.js");
@@ -34,14 +36,16 @@ class PonyfillBody {
         this.contentLength = contentLength;
         this.bodyType = bodyType;
         this._buffer = buffer;
+        this._signal = options.signal;
     }
     bodyType;
     _bodyFactory = () => null;
     _generatedBody = null;
     _buffer;
+    _signal;
     generateBody() {
         if (this._generatedBody?.readable?.destroyed && this._buffer) {
-            this._generatedBody.readable = stream_1.Readable.from(this._buffer);
+            this._generatedBody.readable = node_stream_1.Readable.from(this._buffer);
         }
         if (this._generatedBody) {
             return this._generatedBody;
@@ -101,48 +105,66 @@ class PonyfillBody {
         return null;
     }
     _chunks = null;
-    _collectChunksFromReadable() {
-        if (this._chunks) {
-            return (0, utils_js_1.fakePromise)(this._chunks);
-        }
+    _doCollectChunksFromReadableJob() {
         if (this.bodyType === BodyInitType.AsyncIterable) {
-            const iterator = this.bodyInit[Symbol.asyncIterator]();
-            const collectValue = () => {
-                return iterator.next().then(({ value, done }) => {
-                    this._chunks ||= [];
-                    if (value) {
-                        this._chunks.push(value);
-                    }
-                    if (!done) {
-                        return collectValue();
-                    }
+            if (Array.fromAsync) {
+                return (0, promise_helpers_1.handleMaybePromise)(() => Array.fromAsync(this.bodyInit), chunks => {
+                    this._chunks = chunks;
                     return this._chunks;
                 });
-            };
+            }
+            const iterator = this.bodyInit[Symbol.asyncIterator]();
+            const chunks = [];
+            const collectValue = () => (0, promise_helpers_1.handleMaybePromise)(() => iterator.next(), ({ value, done }) => {
+                if (value) {
+                    chunks.push(value);
+                }
+                if (!done) {
+                    return collectValue();
+                }
+                this._chunks = chunks;
+                return this._chunks;
+            });
             return collectValue();
         }
         const _body = this.generateBody();
         if (!_body) {
-            return (0, utils_js_1.fakePromise)([]);
+            this._chunks = [];
+            return (0, utils_js_1.fakePromise)(this._chunks);
         }
-        this._chunks = [];
-        _body.readable.on('data', chunk => {
-            this._chunks.push(chunk);
-        });
+        if (_body.readable.destroyed) {
+            return (0, utils_js_1.fakePromise)((this._chunks = []));
+        }
+        const chunks = [];
         return new Promise((resolve, reject) => {
-            _body.readable.once('end', () => {
-                resolve(this._chunks);
+            _body.readable.on('data', chunk => {
+                chunks.push(chunk);
             });
-            _body.readable.once('error', e => {
-                reject(e);
+            _body.readable.once('error', reject);
+            _body.readable.once('end', () => {
+                resolve((this._chunks = chunks));
             });
         });
     }
+    _collectChunksFromReadable() {
+        if (this._chunks) {
+            return (0, utils_js_1.fakePromise)(this._chunks);
+        }
+        this._chunks ||= this._doCollectChunksFromReadableJob();
+        return this._chunks;
+    }
     _blob = null;
     blob() {
         if (this._blob) {
             return (0, utils_js_1.fakePromise)(this._blob);
         }
+        if (this.bodyType === BodyInitType.String) {
+            this._text = this.bodyInit;
+            this._blob = new Blob_js_1.PonyfillBlob([this._text], {
+                type: this.contentType || 'text/plain;charset=UTF-8',
+                size: this.contentLength,
+            });
+        }
         if (this.bodyType === BodyInitType.Blob) {
             this._blob = this.bodyInit;
             return (0, utils_js_1.fakePromise)(this._blob);
@@ -154,13 +176,13 @@ class PonyfillBody {
             });
             return (0, utils_js_1.fakePromise)(this._blob);
         }
-        return this._collectChunksFromReadable().then(chunks => {
+        return (0, utils_js_1.fakePromise)((0, promise_helpers_1.handleMaybePromise)(() => this._collectChunksFromReadable(), chunks => {
             this._blob = new Blob_js_1.PonyfillBlob(chunks, {
                 type: this.contentType || '',
                 size: this.contentLength,
             });
             return this._blob;
-        });
+        }));
     }
     _formData = null;
     formData(opts) {
@@ -181,61 +203,108 @@ class PonyfillBody {
             ...opts?.formDataLimits,
         };
         return new Promise((resolve, reject) => {
-            const bb = (0, busboy_1.default)({
+            const stream = this.body?.readable;
+            if (!stream) {
+                return reject(new Error('No stream available'));
+            }
+            // form data file that is currently being processed, it's
+            // important to keep track of it in case the stream ends early
+            let currFile = null;
+            const bb = new busboy_1.Busboy({
                 headers: {
+                    'content-length': typeof this.contentLength === 'number'
+                        ? this.contentLength.toString()
+                        : this.contentLength || '',
                     'content-type': this.contentType || '',
                 },
                 limits: formDataLimits,
-                defParamCharset: 'utf-8',
+                defCharset: 'utf-8',
             });
-            bb.on('field', (name, value, { nameTruncated, valueTruncated }) => {
-                if (nameTruncated) {
-                    reject(new Error(`Field name size exceeded: ${formDataLimits?.fieldNameSize} bytes`));
+            if (this._signal) {
+                (0, node_stream_1.addAbortSignal)(this._signal, bb);
+            }
+            let completed = false;
+            const complete = (err) => {
+                if (completed)
+                    return;
+                completed = true;
+                stream.unpipe(bb);
+                bb.destroy();
+                if (currFile) {
+                    currFile.destroy();
+                    currFile = null;
+                }
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    // no error occured, this is a successful end/complete/finish
+                    resolve(this._formData);
+                }
+            };
+            // we dont need to listen to the stream close event because bb will close or error when necessary
+            // stream.on('close', complete);
+            // stream can be aborted, for example
+            stream.on('error', complete);
+            bb.on('field', (name, value, fieldnameTruncated, valueTruncated) => {
+                if (fieldnameTruncated) {
+                    return complete(new Error(`Field name size exceeded: ${formDataLimits?.fieldNameSize} bytes`));
                 }
                 if (valueTruncated) {
-                    reject(new Error(`Field value size exceeded: ${formDataLimits?.fieldSize} bytes`));
+                    return complete(new Error(`Field value size exceeded: ${formDataLimits?.fieldSize} bytes`));
                 }
                 this._formData.set(name, value);
             });
-            bb.on('fieldsLimit', () => {
-                reject(new Error(`Fields limit exceeded: ${formDataLimits?.fields}`));
-            });
-            bb.on('file', (name, fileStream, { filename, mimeType }) => {
+            bb.on('file', (name, fileStream, filename, _transferEncoding, mimeType) => {
+                currFile = fileStream;
                 const chunks = [];
-                fileStream.on('limit', () => {
-                    reject(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
-                });
                 fileStream.on('data', chunk => {
                     chunks.push(chunk);
                 });
+                fileStream.on('error', complete);
+                fileStream.on('limit', () => {
+                    complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+                });
                 fileStream.on('close', () => {
                     if (fileStream.truncated) {
-                        reject(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
+                        complete(new Error(`File size limit exceeded: ${formDataLimits?.fileSize} bytes`));
                     }
+                    currFile = null;
                     const file = new File_js_1.PonyfillFile(chunks, filename, { type: mimeType });
                     this._formData.set(name, file);
                 });
             });
+            bb.on('fieldsLimit', () => {
+                complete(new Error(`Fields limit exceeded: ${formDataLimits?.fields}`));
+            });
             bb.on('filesLimit', () => {
-                reject(new Error(`Files limit exceeded: ${formDataLimits?.files}`));
+                complete(new Error(`Files limit exceeded: ${formDataLimits?.files}`));
             });
             bb.on('partsLimit', () => {
-                reject(new Error(`Parts limit exceeded: ${formDataLimits?.parts}`));
-            });
-            bb.on('close', () => {
-                resolve(this._formData);
-            });
-            bb.on('error', (err = 'An error occurred while parsing the form data') => {
-                const errMessage = err.message || err.toString();
-                reject(new TypeError(errMessage, err.cause));
+                complete(new Error(`Parts limit exceeded: ${formDataLimits?.parts}`));
             });
-            _body?.readable.pipe(bb);
+            bb.on('end', complete);
+            bb.on('finish', complete);
+            bb.on('close', complete);
+            bb.on('error', complete);
+            stream.pipe(bb);
         });
     }
     buffer() {
         if (this._buffer) {
             return (0, utils_js_1.fakePromise)(this._buffer);
         }
+        if (this._text) {
+            this._buffer = node_buffer_1.Buffer.from(this._text, 'utf-8');
+            return (0, utils_js_1.fakePromise)(this._buffer);
+        }
+        if (this.bodyType === BodyInitType.String) {
+            return this.text().then(text => {
+                this._text = text;
+                this._buffer = node_buffer_1.Buffer.from(text, 'utf-8');
+                return this._buffer;
+            });
+        }
         if (this.bodyType === BodyInitType.Blob) {
             if ((0, Blob_js_1.hasBufferMethod)(this.bodyInit)) {
                 return this.bodyInit.buffer().then(buf => {
@@ -245,31 +314,31 @@ class PonyfillBody {
             }
             if ((0, Blob_js_1.hasBytesMethod)(this.bodyInit)) {
                 return this.bodyInit.bytes().then(bytes => {
-                    this._buffer = Buffer.from(bytes);
+                    this._buffer = node_buffer_1.Buffer.from(bytes);
                     return this._buffer;
                 });
             }
             if ((0, Blob_js_1.hasArrayBufferMethod)(this.bodyInit)) {
                 return this.bodyInit.arrayBuffer().then(buf => {
-                    this._buffer = Buffer.from(buf, undefined, buf.byteLength);
+                    this._buffer = node_buffer_1.Buffer.from(buf, undefined, buf.byteLength);
                     return this._buffer;
                 });
             }
         }
-        return this._collectChunksFromReadable().then(chunks => {
+        return (0, utils_js_1.fakePromise)((0, promise_helpers_1.handleMaybePromise)(() => this._collectChunksFromReadable(), chunks => {
             if (chunks.length === 1) {
                 this._buffer = chunks[0];
                 return this._buffer;
             }
-            this._buffer = Buffer.concat(chunks);
+            this._buffer = node_buffer_1.Buffer.concat(chunks);
             return this._buffer;
-        });
+        }));
     }
     bytes() {
         return this.buffer();
     }
     arrayBuffer() {
-        // @ts-expect-error - `Buffer` and `ArrayBuffer` are compatible
+        // @ts-ignore - Mismatch between Buffer and ArrayBuffer
         return this.buffer();
     }
     _json = null;
@@ -315,80 +384,81 @@ function processBodyInit(bodyInit) {
         };
     }
     if (typeof bodyInit === 'string') {
-        const buffer = Buffer.from(bodyInit);
-        const contentLength = buffer.byteLength;
+        const contentLength = node_buffer_1.Buffer.byteLength(bodyInit);
         return {
             bodyType: BodyInitType.String,
             contentType: 'text/plain;charset=UTF-8',
             contentLength,
-            buffer,
             bodyFactory() {
-                const readable = stream_1.Readable.from(buffer);
+                const readable = node_stream_1.Readable.from(node_buffer_1.Buffer.from(bodyInit, 'utf-8'));
                 return new ReadableStream_js_1.PonyfillReadableStream(readable);
             },
         };
     }
-    if (Buffer.isBuffer(bodyInit)) {
+    if (node_buffer_1.Buffer.isBuffer(bodyInit)) {
+        const buffer = bodyInit;
         return {
             bodyType: BodyInitType.Buffer,
             contentType: null,
             contentLength: bodyInit.length,
             buffer: bodyInit,
             bodyFactory() {
-                const readable = stream_1.Readable.from(bodyInit);
+                const readable = node_stream_1.Readable.from(buffer);
                 const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
                 return body;
             },
         };
     }
     if ((0, utils_js_1.isArrayBufferView)(bodyInit)) {
-        const buffer = Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength);
+        const buffer = node_buffer_1.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 readable = node_stream_1.Readable.from(buffer);
                 const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
                 return body;
             },
         };
     }
     if (bodyInit instanceof ReadableStream_js_1.PonyfillReadableStream && bodyInit.readable != null) {
+        const readableStream = bodyInit;
         return {
             bodyType: BodyInitType.ReadableStream,
-            bodyFactory: () => bodyInit,
+            bodyFactory: () => readableStream,
             contentType: null,
             contentLength: null,
         };
     }
     if (isBlob(bodyInit)) {
+        const blob = bodyInit;
         return {
             bodyType: BodyInitType.Blob,
             contentType: bodyInit.type,
             contentLength: bodyInit.size,
             bodyFactory() {
-                return bodyInit.stream();
+                return blob.stream();
             },
         };
     }
     if (bodyInit instanceof ArrayBuffer) {
         const contentLength = bodyInit.byteLength;
-        const buffer = Buffer.from(bodyInit, undefined, bodyInit.byteLength);
+        const buffer = node_buffer_1.Buffer.from(bodyInit, undefined, bodyInit.byteLength);
         return {
             bodyType: BodyInitType.Buffer,
             contentType: null,
             contentLength,
             buffer,
             bodyFactory() {
-                const readable = stream_1.Readable.from(buffer);
+                const readable = node_stream_1.Readable.from(buffer);
                 const body = new ReadableStream_js_1.PonyfillReadableStream(readable);
                 return body;
             },
         };
     }
-    if (bodyInit instanceof stream_1.Readable) {
+    if (bodyInit instanceof node_stream_1.Readable) {
         return {
             bodyType: BodyInitType.Readable,
             contentType: null,
@@ -406,7 +476,7 @@ function processBodyInit(bodyInit) {
             contentType,
             contentLength: null,
             bodyFactory() {
-                const body = new ReadableStream_js_1.PonyfillReadableStream(stream_1.Readable.from(bodyInit.toString()));
+                const body = new ReadableStream_js_1.PonyfillReadableStream(node_stream_1.Readable.from(bodyInit.toString()));
                 return body;
             },
         };
@@ -438,7 +508,7 @@ function processBodyInit(bodyInit) {
             contentLength: null,
             bodyType: BodyInitType.AsyncIterable,
             bodyFactory() {
-                const readable = stream_1.Readable.from(bodyInit);
+                const readable = node_stream_1.Readable.from(bodyInit);
                 return new ReadableStream_js_1.PonyfillReadableStream(readable);
             },
         };
@@ -449,7 +519,7 @@ function isFormData(value) {
     return value?.forEach != null;
 }
 function isBlob(value) {
-    return value?.stream != null;
+    return value?.stream != null && typeof value.stream === 'function';
 }
 function isURLSearchParams(value) {
     return value?.sort != null;