@whatwg-node/node-fetch 0.0.7-alpha-20230209150810-7d2cb9f → 0.0.7-alpha-20230209162208-3a05ba1

package/Blob.d.ts

@@ -1,12 +1,17 @@
 /// <reference types="node" />
-import { Blob as NodeBlob } from 'buffer';
-declare const PonyfillBlob_base: typeof NodeBlob;
-export declare class PonyfillBlob extends PonyfillBlob_base implements Blob {
+import { BlobOptions } from 'buffer';
+export declare class PonyfillBlob implements Blob {
+    private blobParts;
+    type: string;
+    private encoding;
+    constructor(blobParts: BlobPart[], options?: BlobOptions);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    get size(): number;
     stream(): any;
-    slice(...args: any[]): any;
+    slice(): any;
 }
 export interface PonyfillBlob {
     prototype: Blob;
     new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
 }
-export {};

package/index.js

@@ -9,7 +9,6 @@ const http = require('http');
 const https = require('https');
 const stream = require('stream');
 const url = require('url');
-const buffer = require('buffer');
 const events = require('@whatwg-node/events');
 const busboy = _interopDefault(require('busboy'));
 
@@ -198,26 +197,127 @@ class PonyfillReadableStream {
     }
 }
 
-class DummyBlob {
-    constructor() {
-        throw new Error('Blob is not supported in this environment, if you are using an older version of Node v14, please upgrade to v14.17.0 or higher');
+function getHeadersObj(headers) {
+    if (headers == null || !('forEach' in headers)) {
+        return headers;
     }
+    const obj = {};
+    headers.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+function uint8ArrayToBuffer(uint8array) {
+    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
+}
+
+function getBlobPartAsBuffer(blobPart) {
+    if (typeof blobPart === 'string') {
+        return Buffer.from(blobPart);
+    }
+    else if (Buffer.isBuffer(blobPart)) {
+        return blobPart;
+    }
+    else if (blobPart instanceof Uint8Array) {
+        return Buffer.from(blobPart);
+    }
+    else if ('buffer' in blobPart) {
+        return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+    }
+    else {
+        return Buffer.from(blobPart);
+    }
+}
+function isBlob(obj) {
+    return obj != null && typeof obj === 'object' && obj.stream != null;
 }
 // Will be removed after v14 reaches EOL
 // Needed because v14 doesn't have .stream() implemented
-class PonyfillBlob extends (buffer.Blob || DummyBlob) {
+class PonyfillBlob {
+    constructor(blobParts, options) {
+        this.blobParts = blobParts;
+        this.type = (options === null || options === void 0 ? void 0 : options.type) || 'application/octet-stream';
+        this.encoding = (options === null || options === void 0 ? void 0 : options.encoding) || 'utf8';
+    }
+    async arrayBuffer() {
+        const bufferChunks = [];
+        for (const blobPart of this.blobParts) {
+            if (isBlob(blobPart)) {
+                const arrayBuf = await blobPart.arrayBuffer();
+                const buf = Buffer.from(arrayBuf, undefined, blobPart.size);
+                bufferChunks.push(buf);
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                bufferChunks.push(buf);
+            }
+        }
+        return uint8ArrayToBuffer(Buffer.concat(bufferChunks));
+    }
+    async text() {
+        let text = '';
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                text += blobPart;
+            }
+            else if ('text' in blobPart) {
+                text += await blobPart.text();
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                text += buf.toString(this.encoding);
+            }
+        }
+        return text;
+    }
+    get size() {
+        let size = 0;
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                size += Buffer.byteLength(blobPart);
+            }
+            else if (isBlob(blobPart)) {
+                size += blobPart.size;
+            }
+            else if ('length' in blobPart) {
+                size += blobPart.length;
+            }
+            else if ('byteLength' in blobPart) {
+                size += blobPart.byteLength;
+            }
+        }
+        return size;
+    }
     stream() {
+        let partQueue = [];
         return new PonyfillReadableStream({
-            start: async (controller) => {
-                const arrayBuffer = await this.arrayBuffer();
-                const buffer = Buffer.from(arrayBuffer);
-                controller.enqueue(buffer);
-                controller.close();
+            start: controller => {
+                partQueue = [...this.blobParts];
+                if (partQueue.length === 0) {
+                    controller.close();
+                }
+            },
+            pull: async (controller) => {
+                const blobPart = partQueue.pop();
+                if (blobPart) {
+                    if (isBlob(blobPart)) {
+                        for await (const chunk of blobPart.stream()) {
+                            controller.enqueue(chunk);
+                        }
+                    }
+                    else {
+                        const buf = getBlobPartAsBuffer(blobPart);
+                        controller.enqueue(buf);
+                    }
+                }
+                else {
+                    controller.close();
+                }
             },
         });
     }
-    slice(...args) {
-        return super.slice(...args);
+    slice() {
+        throw new Error('Not implemented');
     }
 }
 
@@ -282,7 +382,7 @@ class PonyfillFormData {
             values = [];
             this.map.set(name, values);
         }
-        const entry = isBlob(value)
+        const entry = isBlob$1(value)
             ? getNormalizedFile(name, value, fileName)
             : value;
         values.push(entry);
@@ -301,7 +401,7 @@ class PonyfillFormData {
         return this.map.has(name);
     }
     set(name, value, fileName) {
-        const entry = isBlob(value)
+        const entry = isBlob$1(value)
             ? getNormalizedFile(name, value, fileName)
             : value;
         this.map.set(name, [entry]);
@@ -383,7 +483,7 @@ function getNormalizedFile(name, blob, fileName) {
     }
     return new PonyfillFile([blob], fileName || name, { type: blob.type });
 }
-function isBlob(value) {
+function isBlob$1(value) {
     return value != null && typeof value === 'object' && typeof value.arrayBuffer === 'function';
 }
 
@@ -452,7 +552,8 @@ class PonyfillBody {
             return this.bodyInit;
         }
         if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.Buffer) {
-            return this.bodyInit.buffer;
+            const typedBodyInit = this.bodyInit;
+            return uint8ArrayToBuffer(typedBodyInit);
         }
         const blob = await this.blob();
         return blob.arrayBuffer();
@@ -653,7 +754,7 @@ function processBodyInit(bodyInit) {
             contentLength,
             contentType: null,
             bodyFactory() {
-                const buffer = Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength);
+                const buffer = Buffer.from(bodyInit);
                 const readable = stream.Readable.from(buffer);
                 const body = new PonyfillReadableStream(readable);
                 return body;
@@ -927,17 +1028,6 @@ class PonyfillResponse extends PonyfillBody {
     }
 }
 
-function getHeadersObj(headers) {
-    if (headers == null || !('forEach' in headers)) {
-        return headers;
-    }
-    const obj = {};
-    headers.forEach((value, key) => {
-        obj[key] = value;
-    });
-    return obj;
-}
-
 function getResponseForFile(url$1) {
     const path = url.fileURLToPath(url$1);
     const readable = fs.createReadStream(path);
@@ -966,7 +1056,7 @@ function fetchPonyfill(info, init) {
                 const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
                 const data = decodeURIComponent(datas.join(','));
                 if (mimeType.endsWith(BASE64_SUFFIX)) {
-                    const buffer = Buffer.from(data, 'base64');
+                    const buffer = Buffer.from(data, 'base64url');
                     const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
                     const file = new PonyfillBlob([buffer], { type: realMimeType });
                     const response = new PonyfillResponse(file, {

package/index.mjs

@@ -3,7 +3,6 @@ import { request as request$1 } from 'http';
 import { request } from 'https';
 import { Readable } from 'stream';
 import { fileURLToPath } from 'url';
-import { Blob } from 'buffer';
 import { EventTarget, CustomEvent } from '@whatwg-node/events';
 import busboy from 'busboy';
 
@@ -192,26 +191,127 @@ class PonyfillReadableStream {
     }
 }
 
-class DummyBlob {
-    constructor() {
-        throw new Error('Blob is not supported in this environment, if you are using an older version of Node v14, please upgrade to v14.17.0 or higher');
+function getHeadersObj(headers) {
+    if (headers == null || !('forEach' in headers)) {
+        return headers;
     }
+    const obj = {};
+    headers.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+function uint8ArrayToBuffer(uint8array) {
+    return uint8array.buffer.slice(uint8array.byteOffset, uint8array.byteOffset + uint8array.byteLength);
+}
+
+function getBlobPartAsBuffer(blobPart) {
+    if (typeof blobPart === 'string') {
+        return Buffer.from(blobPart);
+    }
+    else if (Buffer.isBuffer(blobPart)) {
+        return blobPart;
+    }
+    else if (blobPart instanceof Uint8Array) {
+        return Buffer.from(blobPart);
+    }
+    else if ('buffer' in blobPart) {
+        return Buffer.from(blobPart.buffer, blobPart.byteOffset, blobPart.byteLength);
+    }
+    else {
+        return Buffer.from(blobPart);
+    }
+}
+function isBlob(obj) {
+    return obj != null && typeof obj === 'object' && obj.stream != null;
 }
 // Will be removed after v14 reaches EOL
 // Needed because v14 doesn't have .stream() implemented
-class PonyfillBlob extends (Blob || DummyBlob) {
+class PonyfillBlob {
+    constructor(blobParts, options) {
+        this.blobParts = blobParts;
+        this.type = (options === null || options === void 0 ? void 0 : options.type) || 'application/octet-stream';
+        this.encoding = (options === null || options === void 0 ? void 0 : options.encoding) || 'utf8';
+    }
+    async arrayBuffer() {
+        const bufferChunks = [];
+        for (const blobPart of this.blobParts) {
+            if (isBlob(blobPart)) {
+                const arrayBuf = await blobPart.arrayBuffer();
+                const buf = Buffer.from(arrayBuf, undefined, blobPart.size);
+                bufferChunks.push(buf);
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                bufferChunks.push(buf);
+            }
+        }
+        return uint8ArrayToBuffer(Buffer.concat(bufferChunks));
+    }
+    async text() {
+        let text = '';
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                text += blobPart;
+            }
+            else if ('text' in blobPart) {
+                text += await blobPart.text();
+            }
+            else {
+                const buf = getBlobPartAsBuffer(blobPart);
+                text += buf.toString(this.encoding);
+            }
+        }
+        return text;
+    }
+    get size() {
+        let size = 0;
+        for (const blobPart of this.blobParts) {
+            if (typeof blobPart === 'string') {
+                size += Buffer.byteLength(blobPart);
+            }
+            else if (isBlob(blobPart)) {
+                size += blobPart.size;
+            }
+            else if ('length' in blobPart) {
+                size += blobPart.length;
+            }
+            else if ('byteLength' in blobPart) {
+                size += blobPart.byteLength;
+            }
+        }
+        return size;
+    }
     stream() {
+        let partQueue = [];
         return new PonyfillReadableStream({
-            start: async (controller) => {
-                const arrayBuffer = await this.arrayBuffer();
-                const buffer = Buffer.from(arrayBuffer);
-                controller.enqueue(buffer);
-                controller.close();
+            start: controller => {
+                partQueue = [...this.blobParts];
+                if (partQueue.length === 0) {
+                    controller.close();
+                }
+            },
+            pull: async (controller) => {
+                const blobPart = partQueue.pop();
+                if (blobPart) {
+                    if (isBlob(blobPart)) {
+                        for await (const chunk of blobPart.stream()) {
+                            controller.enqueue(chunk);
+                        }
+                    }
+                    else {
+                        const buf = getBlobPartAsBuffer(blobPart);
+                        controller.enqueue(buf);
+                    }
+                }
+                else {
+                    controller.close();
+                }
             },
         });
     }
-    slice(...args) {
-        return super.slice(...args);
+    slice() {
+        throw new Error('Not implemented');
     }
 }
 
@@ -276,7 +376,7 @@ class PonyfillFormData {
             values = [];
             this.map.set(name, values);
         }
-        const entry = isBlob(value)
+        const entry = isBlob$1(value)
             ? getNormalizedFile(name, value, fileName)
             : value;
         values.push(entry);
@@ -295,7 +395,7 @@ class PonyfillFormData {
         return this.map.has(name);
     }
     set(name, value, fileName) {
-        const entry = isBlob(value)
+        const entry = isBlob$1(value)
             ? getNormalizedFile(name, value, fileName)
             : value;
         this.map.set(name, [entry]);
@@ -377,7 +477,7 @@ function getNormalizedFile(name, blob, fileName) {
     }
     return new PonyfillFile([blob], fileName || name, { type: blob.type });
 }
-function isBlob(value) {
+function isBlob$1(value) {
     return value != null && typeof value === 'object' && typeof value.arrayBuffer === 'function';
 }
 
@@ -446,7 +546,8 @@ class PonyfillBody {
             return this.bodyInit;
         }
         if (this.bodyType === BodyInitType.Uint8Array || this.bodyType === BodyInitType.Buffer) {
-            return this.bodyInit.buffer;
+            const typedBodyInit = this.bodyInit;
+            return uint8ArrayToBuffer(typedBodyInit);
         }
         const blob = await this.blob();
         return blob.arrayBuffer();
@@ -647,7 +748,7 @@ function processBodyInit(bodyInit) {
             contentLength,
             contentType: null,
             bodyFactory() {
-                const buffer = Buffer.from(bodyInit.buffer, bodyInit.byteOffset, bodyInit.byteLength);
+                const buffer = Buffer.from(bodyInit);
                 const readable = Readable.from(buffer);
                 const body = new PonyfillReadableStream(readable);
                 return body;
@@ -921,17 +1022,6 @@ class PonyfillResponse extends PonyfillBody {
     }
 }
 
-function getHeadersObj(headers) {
-    if (headers == null || !('forEach' in headers)) {
-        return headers;
-    }
-    const obj = {};
-    headers.forEach((value, key) => {
-        obj[key] = value;
-    });
-    return obj;
-}
-
 function getResponseForFile(url) {
     const path = fileURLToPath(url);
     const readable = createReadStream(path);
@@ -960,7 +1050,7 @@ function fetchPonyfill(info, init) {
                 const [mimeType = 'text/plain', ...datas] = url.pathname.split(',');
                 const data = decodeURIComponent(datas.join(','));
                 if (mimeType.endsWith(BASE64_SUFFIX)) {
-                    const buffer = Buffer.from(data, 'base64');
+                    const buffer = Buffer.from(data, 'base64url');
                     const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
                     const file = new PonyfillBlob([buffer], { type: realMimeType });
                     const response = new PonyfillResponse(file, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.0.7-alpha-20230209150810-7d2cb9f",
+  "version": "0.0.7-alpha-20230209162208-3a05ba1",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "peerDependencies": {

package/utils.d.ts

@@ -1 +1,2 @@
 export declare function getHeadersObj(headers: Headers): Record<string, string>;
+export declare function uint8ArrayToBuffer(uint8array: Uint8Array): ArrayBuffer;