@webqit/fetch-plus 0.1.30 → 0.1.31

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.31",
   "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/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 () {