@whatwg-node/node-fetch 0.5.0-alpha-20230714132731-d012863 → 0.5.0-alpha-20231025081004-47fb219

package/esm/Body.js

@@ -4,17 +4,15 @@ import { PonyfillBlob } from './Blob.js';
 import { PonyfillFile } from './File.js';
 import { getStreamFromFormData, PonyfillFormData } from './FormData.js';
 import { PonyfillReadableStream } from './ReadableStream.js';
-import { uint8ArrayToArrayBuffer } from './utils.js';
+import { fakePromise, isArrayBufferView } from './utils.js';
 var BodyInitType;
 (function (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 = {}));
 export class PonyfillBody {
     constructor(bodyInit, options = {}) {
@@ -25,11 +23,12 @@ export 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) {
@@ -65,76 +64,50 @@ export 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 uint8ArrayToArrayBuffer(typedBodyInit);
-        }
-        if (this.bodyType === BodyInitType.String) {
-            const buffer = Buffer.from(this.bodyInit);
-            return 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();
-    }
     _collectChunksFromReadable() {
+        const _body = this.generateBody();
+        if (!_body) {
+            return fakePromise([]);
+        }
+        const chunks = [];
+        _body.readable.on('data', chunk => {
+            chunks.push(chunk);
+        });
         return new Promise((resolve, reject) => {
-            const chunks = [];
-            const _body = this.generateBody();
-            if (_body) {
-                _body.readable.on('data', chunk => {
-                    chunks.push(chunk);
-                });
-                _body.readable.on('end', () => {
-                    resolve(chunks);
-                });
-                _body.readable.on('error', e => {
-                    reject(e);
-                });
-            }
-            return chunks;
+            _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 fakePromise(this.bodyInit);
         }
-        if (this.bodyType === BodyInitType.String ||
-            this.bodyType === BodyInitType.Buffer ||
-            this.bodyType === BodyInitType.Uint8Array) {
-            const bodyInitTyped = this.bodyInit;
-            return new PonyfillBlob([bodyInitTyped], {
+        if (this._buffer) {
+            const blob = new PonyfillBlob([this._buffer], {
                 type: this.contentType || '',
+                size: this.contentLength,
             });
+            return fakePromise(blob);
         }
-        if (this.bodyType === BodyInitType.ArrayBuffer) {
-            const bodyInitTyped = this.bodyInit;
-            const buf = Buffer.from(bodyInitTyped, undefined, bodyInitTyped.byteLength);
-            return new PonyfillBlob([buf], {
+        return this._collectChunksFromReadable().then(chunks => {
+            return new PonyfillBlob(chunks, {
                 type: this.contentType || '',
+                size: this.contentLength,
             });
-        }
-        const chunks = await this._collectChunksFromReadable();
-        return new PonyfillBlob(chunks, {
-            type: this.contentType || '',
         });
     }
     formData(opts) {
         if (this.bodyType === BodyInitType.FormData) {
-            return Promise.resolve(this.bodyInit);
+            return fakePromise(this.bodyInit);
         }
         const formData = new PonyfillFormData();
         const _body = this.generateBody();
         if (_body == null) {
-            return Promise.resolve(formData);
+            return fakePromise(formData);
         }
         const formDataLimits = {
             ...this.options.formDataLimits,
@@ -166,7 +139,7 @@ export 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) {
@@ -191,39 +164,36 @@ export 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 fakePromise(this._buffer);
         }
         if (this.bodyType === BodyInitType.Blob) {
             if (this.bodyInit instanceof 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 fakePromise(this.bodyInit);
         }
-        const buffer = await this.buffer();
-        return buffer.toString('utf-8');
+        return this.arrayBuffer().then(buffer => buffer.toString('utf-8'));
     }
 }
 function processBodyInit(bodyInit) {
@@ -241,18 +211,19 @@ function processBodyInit(bodyInit) {
             bodyType: BodyInitType.String,
             contentType: 'text/plain;charset=UTF-8',
             contentLength,
+            buffer,
             bodyFactory() {
                 const readable = Readable.from(buffer);
                 return new 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 = Readable.from(bodyInit);
                 const body = new PonyfillReadableStream(readable);
@@ -260,6 +231,20 @@ function processBodyInit(bodyInit) {
             },
         };
     }
+    if (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 = Readable.from(buffer);
+                const body = new PonyfillReadableStream(readable);
+                return body;
+            },
+        };
+    }
     if (bodyInit instanceof PonyfillReadableStream) {
         return {
             bodyType: BodyInitType.ReadableStream,
@@ -268,7 +253,7 @@ function processBodyInit(bodyInit) {
             contentLength: null,
         };
     }
-    if (bodyInit instanceof PonyfillBlob) {
+    if (isBlob(bodyInit)) {
         return {
             bodyType: BodyInitType.Blob,
             contentType: bodyInit.type,
@@ -278,40 +263,15 @@ function processBodyInit(bodyInit) {
             },
         };
     }
-    if (bodyInit instanceof Uint8Array) {
-        const contentLength = bodyInit.byteLength;
-        return {
-            bodyType: BodyInitType.Uint8Array,
-            contentLength,
-            contentType: null,
-            bodyFactory() {
-                const readable = Readable.from(bodyInit);
-                const body = new PonyfillReadableStream(readable);
-                return body;
-            },
-        };
-    }
-    if ('buffer' in bodyInit) {
-        const contentLength = bodyInit.byteLength;
-        return {
-            contentLength,
-            contentType: null,
-            bodyFactory() {
-                const buffer = Buffer.from(bodyInit);
-                const readable = Readable.from(buffer);
-                const body = new 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 = Readable.from(buffer);
                 const body = new PonyfillReadableStream(readable);
                 return body;
@@ -329,18 +289,7 @@ function processBodyInit(bodyInit) {
             },
         };
     }
-    if ('stream' in bodyInit) {
-        return {
-            contentType: bodyInit.type,
-            contentLength: bodyInit.size,
-            bodyFactory() {
-                const bodyStream = bodyInit.stream();
-                const body = new 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,
@@ -352,10 +301,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() {
@@ -375,3 +325,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/esm/FormData.js

@@ -1,4 +1,3 @@
-import { PonyfillFile } from './File.js';
 import { PonyfillReadableStream } from './ReadableStream.js';
 export class PonyfillFormData {
     constructor() {
@@ -113,17 +112,9 @@ export function getStreamFromFormData(formData, boundary = '---') {
     });
 }
 function getNormalizedFile(name, blob, fileName) {
-    if (blob instanceof PonyfillFile) {
-        if (fileName != null) {
-            return new PonyfillFile([blob], fileName, {
-                type: blob.type,
-                lastModified: blob.lastModified,
-            });
-        }
-        return blob;
-    }
-    return new 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/esm/Headers.js

@@ -20,7 +20,7 @@ export 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/esm/ReadableStream.js

@@ -33,23 +33,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;
+}
 export 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 Readable({
@@ -159,6 +165,6 @@ export class PonyfillReadableStream {
         return readable;
     }
     static [Symbol.hasInstance](instance) {
-        return instance != null && typeof instance === 'object' && 'getReader' in instance;
+        return isReadableStream(instance);
     }
 }

package/esm/Request.js

@@ -3,6 +3,9 @@ import { isHeadersLike, PonyfillHeaders } from './Headers.js';
 function isRequest(input) {
     return input[Symbol.toStringTag] === 'Request';
 }
+function isURL(obj) {
+    return obj?.href != null;
+}
 export class PonyfillRequest extends PonyfillBody {
     constructor(input, options) {
         let url;
@@ -11,7 +14,7 @@ export class PonyfillRequest extends PonyfillBody {
         if (typeof input === 'string') {
             url = input;
         }
-        else if ('href' in input) {
+        else if (isURL(input)) {
             url = input.toString();
         }
         else if (isRequest(input)) {

package/esm/TextEncoderDecoder.js

@@ -1,3 +1,4 @@
+import { isArrayBufferView } from './utils.js';
 export class PonyfillTextEncoder {
     constructor(encoding = 'utf-8') {
         this.encoding = encoding;
@@ -25,6 +26,12 @@ export class PonyfillTextDecoder {
         }
     }
     decode(input) {
+        if (Buffer.isBuffer(input)) {
+            return input.toString(this.encoding);
+        }
+        if (isArrayBufferView(input)) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
+        }
         return Buffer.from(input).toString(this.encoding);
     }
 }

package/esm/URLSearchParams.js

@@ -1,4 +1,7 @@
 import FastQuerystring from 'fast-querystring';
+function isURLSearchParams(value) {
+    return value?.entries != null;
+}
 export class PonyfillURLSearchParams {
     constructor(init) {
         if (init) {
@@ -11,7 +14,7 @@ export 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;

package/esm/fetch.js

@@ -1,10 +1,10 @@
 import { createReadStream } from 'fs';
 import { fileURLToPath } from 'url';
-import { PonyfillBlob } from './Blob.js';
 import { fetchCurl } from './fetchCurl.js';
 import { fetchNodeHttp } from './fetchNodeHttp.js';
 import { PonyfillRequest } from './Request.js';
 import { PonyfillResponse } from './Response.js';
+import { fakePromise } from './utils.js';
 const BASE64_SUFFIX = ';base64';
 function getResponseForFile(url) {
     const path = fileURLToPath(url);
@@ -12,15 +12,17 @@ function getResponseForFile(url) {
     return new 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 PonyfillBlob([buffer], { type: realMimeType });
-        return new PonyfillResponse(file, {
+        return new PonyfillResponse(buffer, {
             status: 200,
             statusText: 'OK',
+            headers: {
+                'content-type': realMimeType,
+            },
         });
     }
     return new PonyfillResponse(data, {
@@ -31,19 +33,22 @@ function getResponseForDataUri(url) {
         },
     });
 }
-export async function fetchPonyfill(info, init) {
-    if (typeof info === 'string' || 'href' in info) {
+function isURL(obj) {
+    return obj != null && obj.href != null;
+}
+export function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || isURL(info)) {
         const ponyfillRequest = new PonyfillRequest(info, init);
         return fetchPonyfill(ponyfillRequest);
     }
     const fetchRequest = info;
     if (fetchRequest.url.startsWith('data:')) {
         const response = getResponseForDataUri(fetchRequest.url);
-        return Promise.resolve(response);
+        return fakePromise(response);
     }
     if (fetchRequest.url.startsWith('file:')) {
         const response = getResponseForFile(fetchRequest.url);
-        return Promise.resolve(response);
+        return fakePromise(response);
     }
     if (globalThis.libcurl) {
         return fetchCurl(fetchRequest);