web-streams-shim 1.0.6 → 1.0.8

package/extensions/Record-stream.js

@@ -0,0 +1,100 @@
+/**
+ * Record Stream Extensions - Minimal stream() method polyfills
+ * 
+ * Adds stream() method to Request, Response, and Blob objects as a convenient
+ * alias for the .body property. This is a lightweight alternative to the full
+ * web-streams-extensions.js that only adds the stream() method.
+ * 
+ * Also adds Blob.body property for API consistency with Request/Response.
+ * 
+ * Use this instead of web-streams-extensions.js when you only need the
+ * stream() alias and don't want the other non-standard extensions.
+ * 
+ * @note Non-standard convenience method
+ */
+(() => {
+    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) => {
+        let type = 'function';
+        if(String(obj).trim().startsWith('class')||/^[A-Z]|^.[A-Z]/.test(obj?.name)){
+            type = 'class';
+        }
+        if(String(obj).trim().startsWith('async')||/async/i.test(obj?.name)){
+            type = 'async function';
+        }
+        for (const str of ['toString', 'toLocaleString', Symbol.toStringTag]) {
+            Object.defineProperty(obj, str, {
+                value: makeStringer(`${type} ${obj.name} { [polyfill code] }`),
+                configurable: true,
+                writable: true,
+                enumerable: false,
+            });
+        }
+        return obj;
+    };
+    
+    for (const record of [Q(() => Request), Q(() => Response)]) {
+        (() => {
+            let currentRecord = record;
+            while(currentRecord.__proto__.name === currentRecord.name) {
+                currentRecord = currentRecord.__proto__;
+            }
+            (currentRecord?.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();})),
+        set:()=>{},
+        configurable:true,
+        enumerable:false
+      });
+    }
+})();

package/extensions/file.js

@@ -1,9 +1,37 @@
+/**
+ * File Constructor Polyfill
+ * 
+ * Provides a File class implementation for environments that lack it, such as:
+ * - Cloudflare Workers
+ * - Google Apps Script
+ * - Some serverless edge runtimes
+ * - Older Node.js versions (pre-20)
+ * 
+ * The File class extends Blob and adds file-specific properties:
+ * - name: The file name
+ * - lastModified: Timestamp in milliseconds
+ * - lastModifiedDate: Date object (deprecated but included for compatibility)
+ * - webkitRelativePath: Empty string (for compatibility)
+ * 
+ * This is a functional implementation that allows File objects to be created
+ * and used in environments where the native File constructor is missing.
+ * 
+ * @note This is a complete implementation, not a partial shim
+ */
 (() => {
     const Q = fn => {
         try {
             return fn?.()
         } catch {}
     };
+    const setHidden = (obj, prop, value) => {
+        Object.defineProperty(obj, prop, {
+            value,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+    }
     const $global = Q(() => globalThis) ?? Q(() => global) ?? Q(() => self) ?? Q(() => window) ?? this;
     if (typeof File === 'undefined') {
         // Sham File class extending Blob
@@ -18,9 +46,9 @@
                 super(bits, blobOptions);
 
                 // Add File-specific properties
-                this['&name'] = filename;
-                this['&lastModified'] = lastModified;
-                this['&lastModifiedDate'] = new Date(lastModified);
+                setHidden(this, '&name', filename);
+                setHidden(this, '&lastModified', lastModified);
+                setHidden(this, '&lastModifiedDate', new Date(lastModified));
             }
 
             get name() {

package/extensions/location.js

@@ -1,3 +1,24 @@
+/**
+ * Location Constructor Polyfill
+ * 
+ * Provides a Location class implementation for environments that lack it, such as:
+ * - Cloudflare Workers
+ * - Deno Deploy
+ * - Vercel Edge Runtime
+ * - Service Workers in some contexts
+ * - Node.js and other server environments
+ * 
+ * The Location class extends URL and adds browser Location API compatibility:
+ * - ancestorOrigins: Empty list (server environments have no origin hierarchy)
+ * - assign(url): Updates the href (no navigation in server context)
+ * - reload(forceReload): No-op with console log (no page to reload)
+ * - replace(url): Updates the href (no navigation in server context)
+ * 
+ * This allows code written for browsers to run in serverless environments
+ * without modification, though navigation methods are no-ops.
+ * 
+ * @note Methods like reload() don't actually navigate - use URL directly for parsing
+ */
 (() => {
     const Q = fn => {
         try {

package/extensions/type-extensions.js

@@ -1,17 +1,122 @@
-(()=>{
-  const typeMap = {
-    blob:Blob,
-    text:TextDecoder,
-    json:JSON,
-    arrayBuffer:ArrayBuffer,
-    stream:ReadableStream,
-    formData:FormData,
-    byte:Uint8Array,
-    slice:Blob
-  };
-  const getMap = {
-    url:URL,
-    headers:Headers,
-    body:ReadableStream
-  };
+/**
+ * Type Extensions - Sets up prototype chains for Web API methods
+ * Extends methods on Request, Response, and Blob to inherit from the class
+ * of the type they return (e.g., Response.prototype.blob extended with Blob)
+ * This provides better runtime type traceability and debugging experience
+ */
+(() => {
+    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;
+    };
+
+    /**
+     * Map of method names to their return type constructors
+     * Methods that return specific types get extended with those types' prototypes
+     */
+    const typeMap = {
+        blob: Q(() => Blob),
+        text: Q(() => TextDecoder),
+        json: Q(() => JSON),
+        arrayBuffer: Q(() => ArrayBuffer),
+        stream: Q(() => ReadableStream),
+        formData: Q(() => FormData),
+        bytes: Q(() => Uint8Array),
+        slice: Q(() => Blob)
+    };
+
+    /**
+     * Map of getter property names to their return type constructors
+     */
+    const getterMap = {
+        url: Q(() => URL),
+        headers: Q(() => Headers),
+        body: Q(() => ReadableStream)
+    };
+
+    /**
+     * Extend methods on Request, Response, and Blob prototypes
+     * to inherit from their return type constructors
+     */
+    for (const record of [Q(() => Request), Q(() => Response), Q(() => Blob)]) {
+        if (!record) continue;
+
+        // Extend methods that return typed values
+        for (const [methodName, TypeClass] of Object.entries(typeMap)) {
+            const method = record.prototype?.[methodName];
+            if (method && TypeClass) {
+                try {
+                    extend(method, TypeClass);
+                } catch (e) {
+                    console.warn(`Failed to extend ${record.name}.prototype.${methodName}`, e);
+                }
+            }
+        }
+
+        // Extend getter properties
+        for (const [propName, TypeClass] of Object.entries(getterMap)) {
+            const descriptor = Object.getOwnPropertyDescriptor(record.prototype, propName);
+            if (descriptor?.get && TypeClass) {
+                try {
+                    extend(descriptor.get, TypeClass);
+                } catch (e) {
+                    console.warn(`Failed to extend ${record.name}.prototype.${propName} getter`, e);
+                }
+            }
+        }
+    }
+
+    // Also extend ArrayBuffer methods if present
+    const arrayBufferMethods = {
+        bytes: Q(() => Uint8Array),
+        slice: Q(() => ArrayBuffer)
+    };
+
+    if (Q(() => ArrayBuffer)) {
+        for (const [methodName, TypeClass] of Object.entries(arrayBufferMethods)) {
+            const method = ArrayBuffer.prototype?.[methodName];
+            if (method && TypeClass) {
+                try {
+                    extend(method, TypeClass);
+                } catch (e) {
+                    console.warn(`Failed to extend ArrayBuffer.prototype.${methodName}`, e);
+                }
+            }
+        }
+    }
 })();
+

package/extensions/web-streams-extensions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TypeScript definitions for web-streams-shim extensions
+ * Additional non-standard convenience methods for Web Streams
+ */
+
+/// <reference lib="dom" />
+/// <reference path="./web-streams-core.d.ts" />
+
+/**
+ * Extended Request interface with additional streaming utilities
+ */
+interface Request {
+  /**
+   * Returns the body as a ReadableStream (alias for body property)
+   * Non-standard convenience method
+   * @returns The request body as a ReadableStream
+   */
+  stream(): ReadableStream<Uint8Array>;
+}
+
+/**
+ * Extended Response interface with additional streaming utilities
+ */
+interface Response {
+  /**
+   * Returns the body as a ReadableStream (alias for body property)
+   * Non-standard convenience method
+   * @returns The response body as a ReadableStream
+   */
+  stream(): ReadableStream<Uint8Array>;
+}
+
+/**
+ * Extended Blob interface with body property and streaming support
+ */
+interface Blob {
+  /**
+   * Returns the blob content as a ReadableStream
+   * Non-standard convenience method that matches Request/Response API
+   * @returns The blob content as a ReadableStream
+   */
+  stream(): ReadableStream<Uint8Array>;
+  
+  /**
+   * The blob content as a ReadableStream
+   * Non-standard property that matches Request/Response API
+   */
+  body: ReadableStream<Uint8Array>;
+  
+  /**
+   * Indicates whether the blob body has been consumed
+   * Non-standard property that matches Request/Response API
+   */
+  bodyUsed: boolean;
+}
+
+export {};