@webqit/fetch-plus 0.1.1

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@webqit/fetch-plus",
+  "publishConfig": {
+    "access": "public"
+  },
+  "title": "Fetch+",
+  "description": "Upgraded fetch and the LiveResponse API",
+  "keywords": [
+    "fetch",
+    "LiveResponse"
+  ],
+  "homepage": "https://fetch-plus.netlify.app/",
+  "icon": "https://webqit.io/icon.svg",
+  "version": "0.1.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webqit/fetch-plus.git"
+  },
+  "bugs": {
+    "url": "https://github.com/webqit/fetch-plus/issues"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "scripts": {
+    "test": "mocha --extension .test.js --recursive --timeout 5000 --exit",
+    "build": "esbuild main=src/index.browser.js --bundle --minify --sourcemap --outdir=dist",
+    "preversion": "npm run test && npm run build && git add -A dist",
+    "postversion": "git push && git push --tags",
+    "version:next": "npm version prerelease --preid=next"
+  },
+  "dependencies": {
+    "@webqit/util": "^0.8.16"
+  },
+  "peerDependencies": {
+    "@webqit/observer": "^3.8.14",
+    "@webqit/port-plus": "^0.1.6"
+  },
+  "devDependencies": {
+    "@webqit/observer": "^3.8.14",
+    "@webqit/port-plus": "^0.1.6",
+    "chai": "^4.3.4",
+    "chai-as-promised": "^7.1.1",
+    "esbuild": "^0.20.2",
+    "mocha": "^10.3.0"
+  },
+  "author": "Oxford Harrison <oxharris.dev@gmail.com>",
+  "maintainers": [
+    "Oxford Harrison <oxharris.dev@gmail.com>"
+  ],
+  "contributors": []
+}

package/src/FormDataPlus.js

@@ -0,0 +1,57 @@
+import { _before } from '@webqit/util/str/index.js';
+import { _isNumeric } from '@webqit/util/js/index.js';
+import { URLSearchParamsPlus } from './URLSearchParamsPlus.js';
+import { dataType, _meta, _wq } from './core.js';
+
+export class FormDataPlus extends FormData {
+
+    static upgradeInPlace(formData) {
+        Object.setPrototypeOf(formData, FormDataPlus.prototype);
+    }
+
+    static json(data = {}, { recursive = true, getIsJsonfiable = false } = {}) {
+        const formData = new FormDataPlus;
+        let isJsonfiable = true;
+
+        URLSearchParamsPlus.reduceValue(data, '', (value, contextPath, suggestedKeys = undefined) => {
+            if (suggestedKeys) {
+                const isJson = dataType(value) === 'json';
+                isJsonfiable = isJsonfiable && isJson;
+                return isJson && suggestedKeys;
+            }
+
+            if (recursive && [true, false, null].includes(value)) {
+                value = new Blob([value + ''], { type: 'application/json' });
+            }
+
+            formData.append(contextPath, value);
+        });
+
+        if (getIsJsonfiable) return [formData, isJsonfiable];
+        return formData;
+    }
+
+    async json({ recursive = true, getIsJsonfiable = false } = {}) {
+        let isJsonfiable = true;
+        let json;
+
+        for (let [name, value] of this.entries()) {
+            if (!json) json = _isNumeric(_before(name, '[')) ? [] : {};
+
+            let type = dataType(value);
+            if (recursive && ['Blob', 'File'].includes(type) && value.type === 'application/json') {
+                let _value = await value.text();
+                value = JSON.parse(_value);
+                type = 'json';
+            }
+
+            isJsonfiable = isJsonfiable && type === 'json';
+            URLSearchParamsPlus.set(json, name, value);
+        }
+
+        if (getIsJsonfiable) return [json, isJsonfiable];
+        return json;
+    }
+}
+
+

package/src/HeadersPlus.js

@@ -0,0 +1,152 @@
+import { _isObject, _isTypeObject } from '@webqit/util/js/index.js';
+import { _from as _arrFrom } from '@webqit/util/arr/index.js';
+import { _after } from '@webqit/util/str/index.js';
+
+export class HeadersPlus extends upgradeMixin(Headers) {
+
+    static upgradeInPlace(headers) {
+        Object.setPrototypeOf(headers, HeadersPlus.prototype);
+    }
+
+    set(name, value) {
+        // Format "Set-Cookie" response header
+        if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+            value = renderCookieObjToString(value);
+        }
+
+        // Format "Cookie" request header
+        if (/Cookie/i.test(name) && _isTypeObject(value)) {
+            value = [].concat(value).map(renderCookieObjToString).join(';');
+        }
+
+        // Format "Content-Range" response header?
+        if (/^Content-Range$/i.test(name) && Array.isArray(value)) {
+            if (value.length < 2 || !value[0].includes('-')) {
+                throw new Error(`A Content-Range array must be in the format: [ 'start-end', 'total' ]`);
+            }
+            value = `bytes ${value.join('/')}`;
+        }
+
+        // Format "Range" request header?
+        if (/^Range$/i.test(name)) {
+            let rangeArr = [];
+            _arrFrom(value).forEach((range, i) => {
+                let rangeStr = Array.isArray(range) ? range.join('-') : range + '';
+                if (i === 0 && !rangeStr.includes('bytes=')) {
+                    rangeStr = `bytes=${rangeStr}`;
+                }
+                rangeArr.push(rangeStr);
+            });
+            value = rangeArr.join(', ');
+        }
+
+        // Format "Accept" request header?
+        if (/^Accept$/i.test(name) && Array.isArray(value)) {
+            value = value.join(',');
+        }
+
+        return super.set(name, value);
+    }
+
+    append(name, value) {
+        // Format "Set-Cookie" response header
+        if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+            value = renderCookieObjToString(value);
+        }
+        return super.append(name, value);
+    }
+
+    get(name, parsed = false) {
+        let value = super.get(name);
+
+        // Parse "Set-Cookie" response header
+        if (/^Set-Cookie$/i.test(name) && parsed) {
+            value = this.getSetCookie()/*IMPORTANT*/.map((str) => {
+                const [cookieDefinition, attrsStr] = str.split(';');
+                const [name, value] = cookieDefinition.split('=').map((s) => s.trim());
+                const cookieObj = { name, value: /*decodeURIComponent*/(value), };
+                attrsStr && attrsStr.split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
+                    cookieObj[attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
+                });
+                return cookieObj;
+            });
+        }
+
+        // Parse "Cookie" request header
+        if (/^Cookie$/i.test(name) && parsed) {
+            value = value?.split(';').map((str) => {
+                const [name, value] = str.split('=').map((s) => s.trim());
+                return { name, value: /*decodeURIComponent*/(value), };
+            }) || [];
+        }
+
+        // Parse "Content-Range" response header?
+        if (/^Content-Range$/i.test(name) && value && parsed) {
+            value = _after(value, 'bytes ').split('/');
+        }
+
+        // Parse "Range" request header?
+        if (/^Range$/i.test(name) && parsed) {
+            value = !value ? [] : _after(value, 'bytes=').split(',').map((rangeStr) => {
+                const range = rangeStr.trim().split('-').map((s) => s ? parseInt(s, 10) : null);
+                range.render = (totalLength) => {
+                    if (range[1] === null) {
+                        range[1] = totalLength - 1;
+                    }
+                    if (range[0] === null) {
+                        range[0] = range[1] ? totalLength - range[1] - 1 : 0;
+                    }
+                    return range
+                };
+                range.isValid = (currentStart, totalLength) => {
+                    // Start higher than end or vice versa?
+                    if (range[0] > range[1] || range[1] < range[0]) return false;
+                    // Stretching beyond valid start/end?
+                    if (range[0] < currentStart || range[1] > totalLength) return false;
+                    return true;
+                };
+                return range;
+            });
+        }
+
+        // Parse "Accept" request header?
+        if (/^Accept$/i.test(name) && value && parsed) {
+            const parseSpec = (spec) => {
+                const [mime, q] = spec.trim().split(';').map((s) => s.trim());
+                return [mime, parseFloat((q || 'q=1').replace('q=', ''))];
+            };
+            const list = value.split(',')
+                .map((spec) => parseSpec(spec))
+                .sort((a, b) => a[1] > b[1] ? -1 : 1) || [];
+            const $value = value;
+            value = {
+                match(mime) {
+                    if (!mime) return 0;
+                    const splitMime = (mime) => mime.split('/').map((s) => s.trim());
+                    const $mime = splitMime(mime + '');
+                    return list.reduce((prev, [entry, q]) => {
+                        if (prev) return prev;
+                        const $entry = splitMime(entry);
+                        return [0, 1].every((i) => (($mime[i] === $entry[i]) || $mime[i] === '*' || $entry[i] === '*')) ? q : 0;
+                    }, 0);
+                },
+                toString() {
+                    return $value;
+                }
+            };
+        }
+
+        return value;
+    }
+}
+
+export function renderCookieObjToString(cookieObj) {
+    const attrsArr = [`${cookieObj.name}=${/*encodeURIComponent*/(cookieObj.value)}`];
+    for (const attrName in cookieObj) {
+        if (['name', 'value'].includes(attrName)) continue;
+        let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
+        if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
+        attrsArr.push(cookieObj[attrName] === true ? _attrName : `${_attrName}=${cookieObj[attrName]}`);
+    }
+    return attrsArr.join('; ');
+}