web-streams-shim 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,6 @@
 ## Web Streams Shim Library
 
-This README provides a comprehensive overview of the features and architectural strategies used in this Web Streams Shim Library, which is designed to integrate modern streams functionality into legacy JavaScript environments.
+The Web Streams Shim Library is designed to create parity between the streaming interfaces within modern runtimes. This does not polyfill the interfaces if they are missing entirely. For that you will want [web-streams-polyfill](https://www.npmjs.com/package/web-streams-polyfill) which is not affiliated with the project.
 
 This library provides essential polyfills and shims to ensure modern Web Streams functionality is available and compliant across environments where native support is missing or incomplete, particularly focusing on `ReadableStream`, `Request`, `Response`, and `Blob` objects.
 
@@ -10,26 +10,27 @@ This library provides essential polyfills and shims to ensure modern Web Streams
 
 The library focuses on extending core browser APIs to meet the latest Web Stream and Fetch specifications.
 
-### 1. ReadableStream Async Iteration and Disposal
+### 1. ReadableStream Async Iteration
 
-The library adds **comprehensive support for modern JavaScript iteration and disposal patterns** to `ReadableStream` and its readers.
+The library adds **comprehensive support for modern JavaScript iteration patterns** to `ReadableStream` and its readers.
 
 | Target | Method/Property | Description |
 | :--- | :--- | :--- |
-| `ReadableStream.prototype` | `[Symbol.asyncIterator]` | Allows the stream to be directly iterable in `for-await-of` loops. It reuses a reader associated with the stream, managed via a `WeakMap`. |
-| `ReadableStream.prototype` | `values()` | An alias for `[Symbol.asyncIterator]` for explicit iteration. |
-| `ReadableStreamDefaultReader.prototype` | `next()` | **Delegates directly to the reader’s native `read()` method**, fulfilling the async iterator requirement. |
-| `ReadableStreamDefaultReader.prototype` | `return(reason)` | Handles early termination (e.g., `break` or `return` within iteration). It safely calls the internal **`terminate` function** to cancel the stream and release the lock. |
-| `ReadableStreamDefaultReader.prototype` | `throw(reason)` | Handles error injection into the iteration. It calls `terminate` to cancel the stream and release the lock, and logs the error. |
-| `ReadableStreamDefaultReader.prototype` | `[Symbol.asyncDispose]` | **Supports the async disposal pattern (`await using`)**. It safely cleans up resources by calling the internal `terminate` function. |
+| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | `[Symbol.asyncIterator]` | Allows the stream to be directly iterable in `for-await-of` loops. |
+| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | `values()` | An alias for `[Symbol.asyncIterator]` for explicit iteration. |
+
+![ReadableStream.asyncIterator](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.@@asyncIterator)
+![ReadableStream.values](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.values)
 
 ### 2. Stream Construction Utility
 
 The library adds the static method for creating streams from existing data sources.
 
-| Target | Method | Description |
+| Target | Method/Property | Description |
 | :--- | :--- | :--- |
-| `ReadableStream` | `from(obj)` | **Creates a new `ReadableStream` from any iterable or async iterable object**. It handles both synchronous and asynchronous iterators, including objects that yield `Promise`-like values. |
+| [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) | [`from(obj)`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/from_static) | **Creates a new `ReadableStream` from any iterable or async iterable object**. It handles both synchronous and asynchronous iterators, including objects that yield `Promise`-like values. |
+
+![ReadableStream.from](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStream.from)
 
 ### 3. Fetch and Body Integration Shims
 
@@ -37,14 +38,32 @@ These shims ensure `Request` and `Response` objects (Records) consistently expos
 
 | Target | Method/Property | Description |
 | :--- | :--- | :--- |
-| `Request.prototype` | `body` (Getter) | Polyfills the `body` property to return a **`ReadableStream` representation of the body content**. This is crucial for environments where `fetch` exists but streaming is absent. |
-| `Response.prototype` | `body` (Getter) | Provides the body content as a `ReadableStream`. The implementation clones the original record, converts the body to a `Blob`, gets the blob's stream, and enqueues chunks via a controller. |
-| `Request.prototype`, `Response.prototype`, `Blob.prototype` | `bytes()` | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. It achieves this by calling the native `arrayBuffer()` and wrapping the result. |
+| `Request` | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Request/body) | Polyfills the `body` property to return a **`ReadableStream` representation of the body content**. This is crucial for environments where `fetch` exists but streaming is absent. |
+| `Response` | [`body`](https://developer.mozilla.org/en-US/docs/Web/API/Response/body) | Provides the body content as a `ReadableStream`. The implementation clones the original record, converts the body to a `Blob`, gets the blob's stream, and enqueues chunks via a controller. |
+| [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/bytes), [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response/bytes), [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob/bytes) | `bytes()` | Adds the `bytes()` method, which **asynchronously returns the object's body/content as a `Uint8Array`**. It achieves this by calling the native `arrayBuffer()` and wrapping the result. |
+
+![Request.body](https://caniuse.smokestack.workers.dev/?feature=api.Request.body)
+![Response.body](https://caniuse.smokestack.workers.dev/?feature=api.Response.body)
+![Request.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Request.bytes)
+![Response.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Response.bytes)
+![Blob.bytes](https://caniuse.smokestack.workers.dev/?feature=api.Blob.bytes)
 
 ### 4. Duplex Compliance Shim
 
 To satisfy modern `fetch` specifications when streaming request bodies, the library ensures compliance for **half-duplex operations**.
 
 *   **Property Injection:** The `duplex: 'half'` property is added to the prototypes of `Request`, `Response`, `ReadableStream`, and `Blob`.
-*   **Constructor Wrapping:** The global `Request` and `Response` constructors are subclassed and **wrapped** to automatically apply the `duplexHalf` utility function to all arguments passed during instantiation.
-*   **Fetch Wrapping:** The global `fetch` function is **wrapped** to automatically apply the `duplexHalf` utility function to its arguments before execution, guaranteeing compliance when streams are used in options.
+*   **Constructor Wrapping:** The global `Request` and `Response` constructors are subclassed and **wrapped** to automatically apply `duplex: 'half'` utility function to all arguments passed during instantiation.
+*   **Fetch Wrapping:** The global `fetch` function is **wrapped** to automatically apply `duplex: 'half'` to its arguments before execution, guaranteeing compliance when streams are used in options.
+
+![Request.duplex](https://caniuse.smokestack.workers.dev/?feature=api.Request.duplex)
+
+### 5. ReadableStreamDefaultReader Constructor Support
+
+The library adds support for the `ReadableStreamDefaultReader` constructor.
+
+| Target | Method/Property | Description |
+| :--- | :--- | :--- |
+| [`ReadableStreamDefaultReader`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader) | [`constructor(stream)`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/ReadableStream) | **Polyfills the `ReadableStreamDefaultReader` constructor** to accept a stream directly. In environments where the native constructor doesn't support this (like Bun), it delegates to `stream.getReader()` and properly sets up the prototype chain. This allows `new ReadableStreamDefaultReader(stream)` to work consistently across all runtimes. |
+
+![ReadableStreamDefaultReader.constructor](https://caniuse.smokestack.workers.dev/?feature=api.ReadableStreamDefaultReader.constructor)

package/ReadableStreamDefaultReader-constructor.js

@@ -103,6 +103,7 @@
                 return $ReadableStreamDefaultReader(stream)
             },$ReadableStreamDefaultReader.prototype)
         },$ReadableStreamDefaultReader));
+        globalThis.ReadableStreamDefaultReader.prototype.constructor = globalThis.ReadableStreamDefaultReader
     }
 
 })();

package/Record-body.js

@@ -267,6 +267,15 @@
                 configurable: true,
                 enumerable: true,
             });
+         if('bodyUsed' in record.prototype)return;
+         Object.defineProperty(record.prototype, "bodyUsed", {
+           get:setStrings(function bodyUsed(){
+             return this.body?.locked;
+           }),
+           set:()=>{},
+           configurable:true,
+           enumerable:true
+         });
         })();
 
 

package/extensions/Recod-stream.js

@@ -0,0 +1,77 @@
+
+(() => {
+    const Q = fn => {
+        try {
+            return fn?.()
+        } catch {}
+    };
+    const constructPrototype = newClass => {
+        try {
+            if (newClass?.prototype) return newClass;
+            const constProto = newClass?.constructor?.prototype;
+            if (constProto) {
+                newClass.prototype = Q(() => constProto?.bind?.(constProto)) ?? Object.create(Object(constProto));
+                return newClass;
+            }
+            newClass.prototype = Q(() => newClass?.bind?.(newClass)) ?? Object.create(Object(newClass));
+        } catch (e) {
+            console.warn(e, newClass);
+        }
+    };
+    const extend = (thisClass, superClass) => {
+        try {
+            constructPrototype(thisClass);
+            constructPrototype(superClass);
+            Object.setPrototypeOf(
+                thisClass.prototype,
+                superClass?.prototype ??
+                superClass?.constructor?.prototype ??
+                superClass
+            );
+            Object.setPrototypeOf(thisClass, superClass);
+
+        } catch (e) {
+            console.warn(e, {
+                thisClass,
+                superClass
+            });
+        }
+        return thisClass;
+    };
+    const makeStringer = str => {
+        const stringer = () => str;
+        ['valueOf', 'toString', 'toLocaleString', Symbol.toPrimitive].forEach(x => {
+            stringer[x] = stringer;
+        });
+        stringer[Symbol.toStringTag] = str;
+        return stringer;
+    };
+    const setStrings = (obj, name) => {
+        for (const str of ['toString', 'toLocaleString', Symbol.toStringTag]) {
+            Object.defineProperty(obj, str, {
+                value: makeStringer(`function ${obj.name}() { [polyfill code] }`),
+                configurable: true,
+                writable: true,
+                enumerable: false,
+            });
+        }
+        return obj;
+    };
+    
+    for (const record of [Q(() => Request), Q(() => Response)]) {
+        (() => {
+            while(record.__proto__.name === record.name) record = record.__proto__;
+            (record?.prototype ?? {}).stream ??= extend(setStrings(function stream() {
+                return this.body;
+            }), Q(() => ReadableStream) ?? {});
+        })();
+    }
+    if(!('body' in Blob.prototype)){
+      Object.defineProperty(Blob.prototype,'body',{
+        get:extend(setStrings(function body(){return this.stream();},ReadableStream)),
+        set:()=>{},
+        configurable:true,
+        enumerable:false
+      });
+    }
+})();

package/extensions/web-streams-extensions.js

@@ -0,0 +1,131 @@
+
+(() => {
+    const Q = fn => {
+        try {
+            return fn?.()
+        } catch {}
+    };
+    const constructPrototype = newClass => {
+        try {
+            if (newClass?.prototype) return newClass;
+            const constProto = newClass?.constructor?.prototype;
+            if (constProto) {
+                newClass.prototype = Q(() => constProto?.bind?.(constProto)) ?? Object.create(Object(constProto));
+                return newClass;
+            }
+            newClass.prototype = Q(() => newClass?.bind?.(newClass)) ?? Object.create(Object(newClass));
+        } catch (e) {
+            console.warn(e, newClass);
+        }
+    };
+    const extend = (thisClass, superClass) => {
+        try {
+            constructPrototype(thisClass);
+            constructPrototype(superClass);
+            Object.setPrototypeOf(
+                thisClass.prototype,
+                superClass?.prototype ??
+                superClass?.constructor?.prototype ??
+                superClass
+            );
+            Object.setPrototypeOf(thisClass, superClass);
+
+        } catch (e) {
+            console.warn(e, {
+                thisClass,
+                superClass
+            });
+        }
+        return thisClass;
+    };
+    const makeStringer = str => {
+        const stringer = () => str;
+        ['valueOf', 'toString', 'toLocaleString', Symbol.toPrimitive].forEach(x => {
+            stringer[x] = stringer;
+        });
+        stringer[Symbol.toStringTag] = str;
+        return stringer;
+    };
+    const setStrings = (obj, name) => {
+        for (const str of ['toString', 'toLocaleString', Symbol.toStringTag]) {
+            Object.defineProperty(obj, str, {
+                value: makeStringer(`function ${obj.name}() { [polyfill code] }`),
+                configurable: true,
+                writable: true,
+                enumerable: false,
+            });
+        }
+        return obj;
+    };
+
+    for (const record of [Q(() => Request), Q(() => Response)]) {
+        (() => {
+            while (record.__proto__.name === record.name) record = record.__proto__;
+            (record?.prototype ?? {}).stream ??= extend(setStrings(function stream() {
+                return this.body;
+            }), Q(() => ReadableStream) ?? {});
+        })();
+    }
+    for (const record of [Q(() => Request), Q(() => Response), Q(() => Blob)]) {
+        (() => {
+            while (record.__proto__.name === record.name) record = record.__proto__;
+            record.prototype[Symbol.asyncIterator] ??= extend(setStrings(Object.defineProperty(function asyncIterator() {
+                return this.stream()[Symbol.asyncIterator]();
+            }, 'name', {
+                value: 'Symbol.asyncIterator',
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            })), ReadableStream.prototype[Symbol.asyncIterator]);
+            record.prototype.values ??= extend(setStrings(function values() {
+                return this[Symbol.asyncIterator]();
+            }), ReadableStream.prototype.values);
+        })();
+    }
+    if (!('body' in Blob.prototype)) {
+        Object.defineProperty(Blob.prototype, 'body', {
+            get: extend(setStrings(function body() {
+                return this.stream();
+            }, ReadableStream)),
+            set: () => {},
+            configurable: true,
+            enumerable: true
+        });
+    }
+    if (!('bodyUsed' in Blob.prototype)) {
+        Object.defineProperty(Blob.prototype, "bodyUsed", {
+            get: setStrings(function bodyUsed() {
+                return this.body?.locked;
+            }),
+            set: () => {},
+            configurable: true,
+            enumerable: true
+        });
+    }
+    Blob.prototype.blob ??= extend(setStrings(function blob() {
+        return this;
+    }), Blob);
+    Blob.prototype.clone ??= extend(setStrings(function clone() {
+        return this.slice();
+    }), Blob);
+    Blob.prototype.formData ??= extend(setStrings(function formData() {
+        return new Response(this).formData();
+    }), FormData);
+    Blob.prototype.json ??= extend(setStrings(function json() {
+        return new Response(this).json();
+    }), JSON);
+    ArrayBuffer.prototype.bytes ??= extend(setStrings(function bytes() {
+        return new Uint8Array(this);
+    }), Uint8Array);
+    ArrayBuffer.prototype[Symbol.iterator] ??= extend(setStrings(Object.defineProperty(function iterator() {
+                return this.bytes()[Symbol.iterator]();
+            }, 'name', {
+                value: 'Symbol.iterator',
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            })), Uint8Array.prototype[Symbol.iterator]);
+    ArrayBuffer.prototype.values ??= extend(setStrings(function values() {
+        return this[Symbol.iterator]();
+    }), Uint8Array.prototype.values);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "web-streams-shim",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "",
   "main": "web-streams-core.js",
   "scripts": {

package/web-streams-core.js

@@ -635,6 +635,15 @@
                     configurable: true,
                     enumerable: true,
                 });
+                if('bodyUsed' in record.prototype)return;
+         Object.defineProperty(record.prototype, "bodyUsed", {
+           get:setStrings(function bodyUsed(){
+             return this.body?.locked;
+           }),
+           set:()=>{},
+           configurable:true,
+           enumerable:true
+         });
             })();
 
 
@@ -839,5 +848,6 @@
                 return $ReadableStreamDefaultReader(stream)
             },$ReadableStreamDefaultReader.prototype)
         },$ReadableStreamDefaultReader));
+        globalThis.ReadableStreamDefaultReader.prototype.constructor = globalThis.ReadableStreamDefaultReader;
     }
 })();