@whatwg-node/node-fetch 0.0.6-alpha-20230207114030-349e836 → 0.0.7-alpha-20230208145746-08ecb64

package/Blob.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Blob as NodeBlob } from 'buffer';
-declare const PonyfillBlob_base: typeof NodeBlob;
-export declare class PonyfillBlob extends PonyfillBlob_base implements Blob {
+declare const BaseBlob: typeof NodeBlob;
+export declare class PonyfillBlob extends BaseBlob implements Blob {
     stream(): any;
     slice(...args: any[]): any;
 }

package/Headers.d.ts

@@ -1,7 +1,12 @@
 export type PonyfillHeadersInit = [string, string][] | Record<string, string | string[] | undefined> | Headers;
 export declare class PonyfillHeaders implements Headers {
+    private headersInit?;
     private map;
-    constructor(headersInit?: PonyfillHeadersInit);
+    private mapIsBuilt;
+    private objectKeysOfeadersInit;
+    constructor(headersInit?: PonyfillHeadersInit | undefined);
+    private _get;
+    private getMap;
     append(name: string, value: string): void;
     get(name: string): string | null;
     has(name: string): boolean;

package/index.js

@@ -184,9 +184,10 @@ class DummyBlob {
         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');
     }
 }
+const BaseBlob = buffer.Blob || DummyBlob;
 // Will be removed after v14 reaches EOL
 // Needed because v14 doesn't have .stream() implemented
-class PonyfillBlob extends (buffer.Blob || DummyBlob) {
+class PonyfillBlob extends BaseBlob {
     stream() {
         return new PonyfillReadableStream({
             start: async (controller) => {
@@ -561,6 +562,15 @@ class PonyfillBody {
             const buffer = Buffer.from(bodyInitTyped, 'byteOffset' in bodyInitTyped ? bodyInitTyped.byteOffset : undefined, bodyInitTyped.byteLength);
             return buffer.toString('utf-8');
         }
+        // perf: avoid reading the stream twice (we read from Readable to create Blob and then we read from Blob to create a string)
+        const _body = this.generateBody();
+        if (_body) {
+            const chunks = [];
+            for await (const chunk of _body.readable) {
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks).toString(this.contentType || 'utf-8');
+        }
         const blob = await this.blob();
         return blob.text();
     }
@@ -718,19 +728,61 @@ function isHeadersLike(headers) {
 }
 class PonyfillHeaders {
     constructor(headersInit) {
+        this.headersInit = headersInit;
         this.map = new Map();
-        if (headersInit != null) {
-            if (Array.isArray(headersInit)) {
-                this.map = new Map(headersInit);
+        this.mapIsBuilt = false;
+        this.objectKeysOfeadersInit = [];
+    }
+    // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
+    _get(key) {
+        // If the map is built, reuse it
+        if (this.mapIsBuilt) {
+            return this.map.get(key.toLowerCase()) || null;
+        }
+        // If the map is not built, try to get the value from the this.headersInit
+        if (this.headersInit == null) {
+            return null;
+        }
+        const normalized = key.toLowerCase();
+        if (Array.isArray(this.headersInit)) {
+            return this.headersInit.find(header => header[0] === normalized);
+        }
+        else if (isHeadersLike(this.headersInit)) {
+            return this.headersInit.get(normalized);
+        }
+        else {
+            const initValue = this.headersInit[key] || this.headersInit[normalized];
+            if (initValue != null) {
+                return initValue;
+            }
+            if (!this.objectKeysOfeadersInit.length) {
+                this.objectKeysOfeadersInit = Object.keys(this.headersInit).map(k => k.toLowerCase());
+            }
+            const index = this.objectKeysOfeadersInit.indexOf(normalized);
+            if (index === -1) {
+                return null;
             }
-            else if (isHeadersLike(headersInit)) {
-                headersInit.forEach((value, key) => {
+            return this.headersInit[index];
+        }
+    }
+    // perf: Build the map of headers lazily, only when we need to access all headers or write to it.
+    // I could do a getter here, but I'm too lazy to type `getter`.
+    getMap() {
+        if (this.mapIsBuilt) {
+            return this.map;
+        }
+        if (this.headersInit != null) {
+            if (Array.isArray(this.headersInit)) {
+                this.map = new Map(this.headersInit);
+            }
+            else if (isHeadersLike(this.headersInit)) {
+                this.headersInit.forEach((value, key) => {
                     this.map.set(key, value);
                 });
             }
             else {
-                for (const initKey in headersInit) {
-                    const initValue = headersInit[initKey];
+                for (const initKey in this.headersInit) {
+                    const initValue = this.headersInit[initKey];
                     if (initValue != null) {
                         const normalizedValue = Array.isArray(initValue) ? initValue.join(', ') : initValue;
                         const normalizedKey = initKey.toLowerCase();
@@ -739,39 +791,48 @@ class PonyfillHeaders {
                 }
             }
         }
+        this.mapIsBuilt = true;
+        return this.map;
     }
     append(name, value) {
         const key = name.toLowerCase();
-        const existingValue = this.map.get(key);
+        const existingValue = this.getMap().get(key);
         const finalValue = existingValue ? `${existingValue}, ${value}` : value;
-        this.map.set(key, finalValue);
+        this.getMap().set(key, finalValue);
     }
     get(name) {
         const key = name.toLowerCase();
-        return this.map.get(key) || null;
+        const value = this._get(key);
+        if (value == null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.join(', ');
+        }
+        return value;
     }
     has(name) {
         const key = name.toLowerCase();
-        return this.map.has(key);
+        return !!this._get(key); // we might need to check if header exists and not just check if it's not nullable
     }
     set(name, value) {
         const key = name.toLowerCase();
-        this.map.set(key, value);
+        this.getMap().set(key, value);
     }
     delete(name) {
         const key = name.toLowerCase();
-        this.map.delete(key);
+        this.getMap().delete(key);
     }
     forEach(callback) {
-        this.map.forEach((value, key) => {
+        this.getMap().forEach((value, key) => {
             callback(value, key, this);
         });
     }
     entries() {
-        return this.map.entries();
+        return this.getMap().entries();
     }
     [Symbol.iterator]() {
-        return this.map.entries();
+        return this.getMap().entries();
     }
 }
 

package/index.mjs

@@ -178,9 +178,10 @@ class DummyBlob {
         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');
     }
 }
+const BaseBlob = Blob || DummyBlob;
 // Will be removed after v14 reaches EOL
 // Needed because v14 doesn't have .stream() implemented
-class PonyfillBlob extends (Blob || DummyBlob) {
+class PonyfillBlob extends BaseBlob {
     stream() {
         return new PonyfillReadableStream({
             start: async (controller) => {
@@ -555,6 +556,15 @@ class PonyfillBody {
             const buffer = Buffer.from(bodyInitTyped, 'byteOffset' in bodyInitTyped ? bodyInitTyped.byteOffset : undefined, bodyInitTyped.byteLength);
             return buffer.toString('utf-8');
         }
+        // perf: avoid reading the stream twice (we read from Readable to create Blob and then we read from Blob to create a string)
+        const _body = this.generateBody();
+        if (_body) {
+            const chunks = [];
+            for await (const chunk of _body.readable) {
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks).toString(this.contentType || 'utf-8');
+        }
         const blob = await this.blob();
         return blob.text();
     }
@@ -712,19 +722,61 @@ function isHeadersLike(headers) {
 }
 class PonyfillHeaders {
     constructor(headersInit) {
+        this.headersInit = headersInit;
         this.map = new Map();
-        if (headersInit != null) {
-            if (Array.isArray(headersInit)) {
-                this.map = new Map(headersInit);
+        this.mapIsBuilt = false;
+        this.objectKeysOfeadersInit = [];
+    }
+    // perf: we don't need to build `this.map` for Requests, as we can access the headers directly
+    _get(key) {
+        // If the map is built, reuse it
+        if (this.mapIsBuilt) {
+            return this.map.get(key.toLowerCase()) || null;
+        }
+        // If the map is not built, try to get the value from the this.headersInit
+        if (this.headersInit == null) {
+            return null;
+        }
+        const normalized = key.toLowerCase();
+        if (Array.isArray(this.headersInit)) {
+            return this.headersInit.find(header => header[0] === normalized);
+        }
+        else if (isHeadersLike(this.headersInit)) {
+            return this.headersInit.get(normalized);
+        }
+        else {
+            const initValue = this.headersInit[key] || this.headersInit[normalized];
+            if (initValue != null) {
+                return initValue;
+            }
+            if (!this.objectKeysOfeadersInit.length) {
+                this.objectKeysOfeadersInit = Object.keys(this.headersInit).map(k => k.toLowerCase());
+            }
+            const index = this.objectKeysOfeadersInit.indexOf(normalized);
+            if (index === -1) {
+                return null;
             }
-            else if (isHeadersLike(headersInit)) {
-                headersInit.forEach((value, key) => {
+            return this.headersInit[index];
+        }
+    }
+    // perf: Build the map of headers lazily, only when we need to access all headers or write to it.
+    // I could do a getter here, but I'm too lazy to type `getter`.
+    getMap() {
+        if (this.mapIsBuilt) {
+            return this.map;
+        }
+        if (this.headersInit != null) {
+            if (Array.isArray(this.headersInit)) {
+                this.map = new Map(this.headersInit);
+            }
+            else if (isHeadersLike(this.headersInit)) {
+                this.headersInit.forEach((value, key) => {
                     this.map.set(key, value);
                 });
             }
             else {
-                for (const initKey in headersInit) {
-                    const initValue = headersInit[initKey];
+                for (const initKey in this.headersInit) {
+                    const initValue = this.headersInit[initKey];
                     if (initValue != null) {
                         const normalizedValue = Array.isArray(initValue) ? initValue.join(', ') : initValue;
                         const normalizedKey = initKey.toLowerCase();
@@ -733,39 +785,48 @@ class PonyfillHeaders {
                 }
             }
         }
+        this.mapIsBuilt = true;
+        return this.map;
     }
     append(name, value) {
         const key = name.toLowerCase();
-        const existingValue = this.map.get(key);
+        const existingValue = this.getMap().get(key);
         const finalValue = existingValue ? `${existingValue}, ${value}` : value;
-        this.map.set(key, finalValue);
+        this.getMap().set(key, finalValue);
     }
     get(name) {
         const key = name.toLowerCase();
-        return this.map.get(key) || null;
+        const value = this._get(key);
+        if (value == null) {
+            return null;
+        }
+        if (Array.isArray(value)) {
+            return value.join(', ');
+        }
+        return value;
     }
     has(name) {
         const key = name.toLowerCase();
-        return this.map.has(key);
+        return !!this._get(key); // we might need to check if header exists and not just check if it's not nullable
     }
     set(name, value) {
         const key = name.toLowerCase();
-        this.map.set(key, value);
+        this.getMap().set(key, value);
     }
     delete(name) {
         const key = name.toLowerCase();
-        this.map.delete(key);
+        this.getMap().delete(key);
     }
     forEach(callback) {
-        this.map.forEach((value, key) => {
+        this.getMap().forEach((value, key) => {
             callback(value, key, this);
         });
     }
     entries() {
-        return this.map.entries();
+        return this.getMap().entries();
     }
     [Symbol.iterator]() {
-        return this.map.entries();
+        return this.getMap().entries();
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whatwg-node/node-fetch",
-  "version": "0.0.6-alpha-20230207114030-349e836",
+  "version": "0.0.7-alpha-20230208145746-08ecb64",
   "description": "Fetch API implementation for Node",
   "sideEffects": false,
   "peerDependencies": {