@webqit/fetch-plus 0.1.30 → 0.1.32

package/package.json

@@ -11,7 +11,7 @@
   ],
   "homepage": "https://fetch-plus.netlify.app/",
   "icon": "https://webqit.io/icon.svg",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/HeadersPlus.js

@@ -111,34 +111,55 @@ export class HeadersPlus extends Headers {
 
         // Parse "Range" request header?
         if (/^Range$/i.test(name) && structured) {
+            const _after = (str, prefix) => str.includes(prefix) ? str.split(prefix)[1] : str;
+
             value = !value ? [] : _after(value, 'bytes=').split(',').map((rangeStr) => {
-                const range = rangeStr.trim().split('-').map((s) => s ? parseInt(s, 10) : null);
+                if (!rangeStr.includes('-')) rangeStr = '-'; // -> [null, null];
+
+                // "0-499" -> [0, 499] | "500-" -> [500, null] | "-500" -> [null, 500]
+                const range = rangeStr.trim().split('-').map((s) => (s.length > 0 ? parseInt(s, 10) : null));
+
                 range.resolveAgainst = (totalLength) => {
-                    const offsets = [...range];
-                    if (typeof offsets[1] !== 'number') {
+                    const offsets = [...range]; // Clone the [start, end] array
+
+                    // 1. Handle Suffix Ranges (e.g., bytes=-500)
+                    if (offsets[0] === null && offsets[1] !== null) {
+                        offsets[0] = Math.max(0, totalLength - offsets[1]);
                         offsets[1] = totalLength - 1;
-                    } else {
-                        offsets[1] = Math.min(offsets[1], totalLength) - 1;
                     }
-                    if (typeof offsets[0] !== 'number') {
-                        offsets[0] = offsets[1] ? totalLength - offsets[1] - 1 : 0;
+                    // 2. Handle Open-ended Ranges (e.g., bytes=500-)
+                    else if (offsets[0] !== null && offsets[1] === null) {
+                        offsets[1] = totalLength - 1;
+                    }
+                    // 3. Handle Normal Ranges (e.g., bytes=0-499)
+                    else if (offsets[0] !== null && offsets[1] !== null) {
+                        offsets[1] = Math.min(offsets[1], totalLength - 1);
                     }
-                    return offsets;
+
+                    return offsets; // Returns [start, end] where both are inclusive indices
                 };
+
                 range.canResolveAgainst = (currentStart, totalLength) => {
-                    const offsets = [
-                        typeof range[0] === 'number' ? range[0] : currentStart,
-                        typeof range[1] === 'number' ? range[1] : totalLength - 1
-                    ];
-                    // Start higher than end or vice versa?
-                    if (offsets[0] > offsets[1]) return false;
-                    // Stretching beyond valid start/end?
-                    if (offsets[0] < currentStart || offsets[1] >= totalLength) return false;
+                    const resolved = range.resolveAgainst(totalLength);
+
+                    // 1. Check for NaN or unparsed nulls (invalid formats)
+                    if (Number.isNaN(resolved[0]) || Number.isNaN(resolved[1]) || resolved[0] === null || resolved[1] === null) {
+                        return false;
+                    }
+
+                    // 2. Validate start (end is always clamped): 
+                    // - Range cannot be inverted (start > end)
+                    // - Start cannot be beyond file length
+                    // - Start cannot be below file start
+                    if (resolved[0] > resolved[1] || resolved[0] >= totalLength || resolved[0] < currentStart) {
+                        return false;
+                    }
+
                     return true;
                 };
-                range.toString = () => {
-                    return rangeStr;
-                };
+
+                range.toString = () => rangeStr;
+
                 return range;
             });
         }

package/src/LiveResponse.js

@@ -1,7 +1,7 @@
 import { _isObject, _isTypeObject } from '@webqit/util/js/index.js';
 import { Observer, ListenerRegistry, Descriptor } from '@webqit/observer';
 import { BroadcastChannelPlus, WebSocketPort, MessagePortPlus } from '@webqit/port-plus';
-import { isTypeStream, _meta, _wq } from './messageParserMixin.js';
+import { isTypeStream, _meta, _wq, isAsyncIterable, isGenerator } from './messageParserMixin.js';
 import { ResponsePlus } from './ResponsePlus.js';
 
 export class LiveResponse extends EventTarget {
@@ -461,10 +461,13 @@ export class LiveResponse extends EventTarget {
                 throw new Error(`frameClosure is not supported for responses.`);
             }
             frame.donePromise = execReplaceWithResponse(frame, body, frameOptions);
-        } else if (isGenerator(body)) {
+        } else if (isAsyncIterable(body) || isGenerator(body)) {
             if (frameClosure) {
                 throw new Error(`frameClosure is not supported for generators.`);
             }
+            if (!isGenerator(body)) {
+                body = body[Symbol.asyncIterator]();
+            }
             frame.donePromise = execReplaceWithGenerator(frame, body, frameOptions);
         } else if (body instanceof LiveProgramHandleX) {
             if (frameClosure) {
@@ -575,12 +578,6 @@ export class LiveResponse extends EventTarget {
     }
 }
 
-export const isGenerator = (obj) => {
-    return typeof obj?.next === 'function' &&
-        typeof obj?.throw === 'function' &&
-        typeof obj?.return === 'function';
-};
-
 export class ReplaceEvent extends Event {
 
     [Symbol.toStringTag] = 'ReplaceEvent';

package/src/messageParserMixin.js

@@ -24,6 +24,14 @@ export function messageParserMixin(superClass) {
 
             // Process body
             let body = httpMessageInit.body;
+
+            if (isAsyncIterable(body) || isGenerator(body)) {
+                body = asyncIterableToStream(body);
+                const type = 'ReadableStream';
+                headers['content-type'] ??= 'application/octet-stream';
+                return { body, headers: new Headers(headers), $type: type };
+            }
+
             let type = [null, undefined].includes(body) ? null : dataType(body);
 
             // Binary bodies
@@ -203,6 +211,8 @@ export function dataType(value) {
     return null;
 }
 
+// --------------
+
 export function isTypeReadable(obj) {
     return (
         obj !== null &&
@@ -217,3 +227,142 @@ export function isTypeStream(obj) {
     return obj instanceof ReadableStream
         || isTypeReadable(obj);
 }
+
+// --------------
+
+export const isGenerator = (obj) => {
+    return typeof obj?.next === 'function'
+        //&& typeof obj?.throw === 'function'
+        //&& typeof obj?.return === 'function';
+};
+
+export function isAsyncIterable(obj) {
+    return (
+        obj !== null &&
+        typeof obj === 'object' &&
+        typeof obj[Symbol.asyncIterator] === 'function'
+    );
+}
+
+export function asyncIterableToStream(iterable) {
+    if (!isAsyncIterable(iterable) && !isGenerator(body)) {
+        throw new TypeError('Body must be an async iterable.');
+    }
+
+    const iterator = isGenerator(iterable) ? iterable : iterable[Symbol.asyncIterator]();
+    const encoder = new TextEncoder();
+    let finished = false;
+
+    const closeIterator = async (reason) => {
+        if (finished) return;
+        finished = true;
+
+        if (typeof iterator.return === 'function') {
+            try {
+                await iterator.return(reason);
+            } catch { }
+        }
+    };
+
+    const encodeChunk = (value) => {
+        if (value == null) return null;
+
+        // Binary passthrough
+        if (value instanceof Uint8Array) {
+            return value;
+        }
+
+        // Text passthrough
+        if (typeof value === 'string') {
+            return encoder.encode(value);
+        }
+
+        // JSON (objects, arrays, numbers, booleans)
+        if (
+            typeof value === 'object' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean'
+        ) {
+            return encoder.encode(JSON.stringify(value) + '\n');
+        }
+
+        throw new TypeError(
+            `Unsupported chunk type in async iterable: ${typeof value}`
+        );
+    };
+
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await iterator.next();
+
+                if (done) {
+                    await closeIterator();
+                    controller.close();
+                    return;
+                }
+
+                const chunk = encodeChunk(value);
+                if (chunk) controller.enqueue(chunk);
+
+            } catch (err) {
+                await closeIterator();
+                controller.error(err);
+            }
+        },
+
+        async cancel(reason) {
+            await closeIterator(reason);
+        }
+    });
+}
+
+function streamToAsyncIterable(stream, { parse = null } = {}) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+
+    let finished = false;
+    let buffer = '';
+
+    const close = async () => {
+        if (finished) return;
+        finished = true;
+        try {
+            await reader.cancel();
+        } catch { }
+        reader.releaseLock();
+    };
+
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                while (true) {
+                    const { value, done } = await reader.read();
+                    if (done) break;
+
+                    if (parse === 'ndjson') {
+                        buffer += decoder.decode(value, { stream: true });
+
+                        let lines = buffer.split('\n');
+                        buffer = lines.pop(); // incomplete fragment
+
+                        for (const line of lines) {
+                            if (line.trim()) yield JSON.parse(line);
+                        }
+
+                        continue;
+                    }
+
+                    yield value;
+                }
+
+                if (parse === 'ndjson' && buffer.trim()) {
+                    yield JSON.parse(buffer);
+                }
+
+            } finally {
+                await close();
+            }
+        }
+    };
+}

package/test/1.basic.test.js

@@ -86,12 +86,12 @@ describe('Core API Tests', function () {
             // "range[0] < currentStart" is check.
             // If currentStart is 500, range 0-499 is NOT valid
 
-            expect(range.canResolveAgainst(0, 400)).to.be.false; // range end > total
+            expect(range.canResolveAgainst(0, 400)).to.be.true; // range end > total, but clamped
 
             // Render
-            // range is [0, 499]
+            // range is [0, 500] -> 501 bytes
             const rendered = range.resolveAgainst(1000);
-            expect(rendered).to.deep.equal([0, 499]);
+            expect(rendered).to.deep.equal([0, 500]);
         });
 
         it('should handle open-ended ranges', function () {