@webqit/webflo 0.11.39 → 0.11.40

package/src/runtime-pi/util-http.js

@@ -0,0 +1,70 @@
+
+/**
+ * @imports
+ */
+import { _isString, _isNumeric, _isObject, _isPlainObject, _isArray, _isPlainArray, _isTypeObject, _isNumber } from '@webqit/util/js/index.js';
+import { _before } from '@webqit/util/str/index.js';
+import { params } from './util-url.js';
+
+export function formatMessage(body) {
+    let type = dataType(body);
+    let headers = {};
+    if ([ 'Blob', 'File' ].includes(type)) {
+        headers = { 'Content-Type': body.type,  'Content-Length': body.size, };
+    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(type)) {
+        headers = {  'Content-Length': body.byteLength, };
+    } else if (type === 'json' && _isTypeObject(body)) {
+        const [ _body, isJsonfiable ] = formData(body);
+        if (isJsonfiable) {
+            body = JSON.stringify(body, (k, v) => v instanceof Error ? { ...v, message: v.message } : v);
+            headers = { 'Content-Type': 'application/json', 'Content-Length': (new Blob([ body ])).size, };
+        } else {
+            body = _body;
+            type = 'FormData';
+        }
+    } else if (type === 'json') {
+        headers = { 'Content-Length': (body + '').length, };
+    }
+    return [ body, headers, type ];
+}
+
+export function formData(data = {}) {
+    const formData = this instanceof FormData ? this : new FormData;
+    let isJsonfiable = true;
+    if (arguments.length) {
+        params.reduceValue(data, '', (value, contextPath, suggestedKeys = undefined) => {
+            if (suggestedKeys) {
+                const isJson = dataType(value) === 'json';
+                isJsonfiable = isJsonfiable && isJson;
+                return isJson && suggestedKeys;
+            }
+            formData.append(contextPath, value);
+        });
+        return [ formData, isJsonfiable ];
+    }
+    let json;
+    for (let [ name, value ] of formData.entries()) {
+        if (!json) { json = _isNumeric(_before(name, '[')) ? [] : {}; }
+        const isJson = dataType(value) === 'json';
+        isJsonfiable = isJsonfiable && isJson;
+        if (value === 'false') { value = false; }
+        if (value === 'true') { value = true; }
+        if (value === 'null') { value = null; }
+        if (value === 'undefined') { value = undefined; }
+        params.set(json, name, value);
+    }
+    return [ json, isJsonfiable ];
+}
+
+export function dataType(value) {
+    if (_isString(value) || _isNumber(value) || value === null) return 'json';
+    if (!_isTypeObject(value)) return;
+    const toStringTag = value[Symbol.toStringTag];
+    const type = [
+        'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer', 'Blob', 'File', 'FormData', 'Stream', 'ReadableStream'
+    ].reduce((_toStringTag, type) => _toStringTag || (toStringTag === type ? type : null), null);
+    if (type) return type;
+    if ((_isObject(value) && _isPlainObject(value)) || (_isArray(value) && _isPlainArray(value)) || 'toString' in value) {
+        return 'json';
+    }
+}

package/src/runtime-pi/util-url.js

@@ -0,0 +1,147 @@
+
+/**
+ * @imports
+ */
+import { _isString, _isNumeric, _isArray, _isTypeObject } from '@webqit/util/js/index.js';
+if (typeof URLPattern === 'undefined') {
+    await import('urlpattern-polyfill');
+}
+
+export const params = {
+    // Parse a search params string into an object
+    parse(str, delim = '&') {
+        str = str || '';
+        const target = {};
+        (str.startsWith('?') ? str.substr(1) : str)
+            .split(delim).filter(q => q).map(q => q.split('=').map(q => q.trim()))
+            .forEach(q => this.set(target, q[0], decodeURIComponent(q[1])));
+        return target;
+    },
+    // Stringify an object into a search params string
+    stringify(targetObject, delim = '&') {
+        const q = [];
+        Object.keys(targetObject).forEach(key => {
+            this.reduceValue(targetObject[key], key, (_value, _pathNotation, suggestedKeys = undefined) => {
+                if (suggestedKeys) return suggestedKeys;
+                q.push(`${_pathNotation}=${encodeURIComponent(_value)}`);
+            });
+        });
+        return q.join(delim);
+    },
+
+    // Get value by path notation
+    get(targetObject, pathNotation) {
+        return this.reducePath(pathNotation, targetObject, (key, _targetObject) => {
+            if (!_targetObject && _targetObject !== 0) return;
+            return _targetObject[key];
+        });
+    },
+    // Set value by path notation
+    set(targetObject, pathNotation, value) {
+        this.reducePath(pathNotation, targetObject, function(_key, _targetObject, suggestedBranch = undefined) {
+            let _value = value;
+            if (suggestedBranch) { _value = suggestedBranch; }
+            if (_key === '' && _isArray(_targetObject)) {
+                _targetObject.push(_value);
+            } else {
+                _targetObject[_key] = _value;
+            }
+            return _value;
+        });
+    },
+    
+    // Resolve a value to its leaf nodes
+    reduceValue(value, contextPath, callback) {
+        if (_isTypeObject(value)) {
+            let suggestedKeys = Object.keys(value);
+            let keys = callback(value, contextPath, suggestedKeys);
+            if (_isArray(keys)) {
+                return keys.forEach(key => {
+                    this.reduceValue(value[key], contextPath ? `${contextPath}[${key}]` : key, callback);
+                });
+            }
+        }
+        callback(value, contextPath);
+    },
+    // Resolve a path to its leaf index
+    reducePath(pathNotation, contextObject, callback) {
+        if (_isString(pathNotation) && pathNotation.endsWith(']') && _isTypeObject(contextObject)) {
+            let [ key, ...rest ] = pathNotation.split('[');
+            if (_isNumeric(key)) { key = parseInt(key); }
+            rest = rest.join('[').replace(']', '');
+            let branch;
+            if (key in contextObject) {
+                branch = contextObject[key];
+            } else {
+                let suggestedBranch = rest === '' || _isNumeric(rest.split('[')[0]) ? [] : {};
+                branch = callback(key, contextObject, suggestedBranch);
+            }
+            return this.reducePath(rest, branch, callback);
+        }
+        if (_isNumeric(pathNotation)) { pathNotation = parseInt(pathNotation); }
+        return callback(pathNotation, contextObject);
+    },    
+};
+
+export const path = {
+    join(/* path segments */) {
+        // Split the inputs into a list of path commands.
+        var parts = [], backsteps = 0;
+        for (var i = 0, l = arguments.length; i < l; i++) {
+            parts = parts.concat(arguments[i].split("/"));
+        }
+        // Interpret the path commands to get the new resolved path.
+        var newParts = [];
+        for (i = 0, l = parts.length; i < l; i++) {
+            var part = parts[i];
+            // Remove leading and trailing slashes
+            // Also remove "." segments
+            if (!part || part === ".") continue;
+            // Interpret ".." to pop the last segment
+            if (part === "..") {
+                if (!newParts.length) backsteps ++;
+                else newParts.pop();
+            }
+            // Push new path segments.
+            else newParts.push(part);
+        }
+        // Preserve the initial slash if there was one.
+        if (parts[0] === "") newParts.unshift("");
+        // Turn back into a single string path.
+        return '../'.repeat(backsteps) + newParts.join("/") || (newParts.length ? "/" : ".");
+    },
+    // A simple function to get the dirname of a path
+    // Trailing slashes are ignored. Leading slash is preserved.
+    dirname(path) {
+        return this.join(path, "..");
+    }
+};
+
+export const pattern = (pattern, baseUrl = null) => ({
+    pattern: new URLPattern(pattern, baseUrl),
+    isPattern() {
+        return Object.keys(this.pattern.keys || {}).some(compName => this.pattern.keys[compName].length);
+    },
+    test(...args) { return this.pattern.test(...args) }, 
+    exec(...args) {
+        let components = this.pattern.exec(...args);
+        if (!components) return;
+        components.vars = Object.keys(this.pattern.keys).reduce(({ named, unnamed }, compName) => {
+            this.pattern.keys[compName].forEach(key => {
+                let value = components[compName].groups[key.name];
+                if (typeof key.name === 'number') {
+                    unnamed.push(value);
+                } else {
+                    named[key.name] = value;
+                }
+            });
+            return { named, unnamed };
+        }, { named: {}, unnamed: [] });
+        components.render = str => {
+            return str.replace(/\$(\$|[0-9A-Z]+)/gi, (a, b) => {
+                return b === '$' ? '$' : (_isNumeric(b) ? components.vars.unnamed[b - 1] : components.vars.named[b]) || '';
+            });
+        }
+        return components;
+    }
+});

package/src/runtime-pi/xFormData.js

@@ -2,59 +2,23 @@
 /**
  * @imports
  */
-import { _isTypeObject, _isNumeric } from '@webqit/util/js/index.js';
-import { _before } from '@webqit/util/str/index.js';
-import { wwwFormSet, wwwFormPathSerializeCallback } from './util.js';
+import { formData } from './util-http.js';
 
  /**
   * The _Headers Mixin
   */
-const xFormData = whatwagFormData => class extends whatwagFormData {
+export default class xFormData extends FormData {
 
-    tee(callback = null) {
-        const formData1 = new this.constructor, formData2 = new this.constructor;
-        for (var [ name, value ] of this.entries()) {
-            const formDataType = formDataType(value);
-            if ((callback && callback(value, name, formDataType)) || (!callback && !formDataType)) {
-                formData1.append(name, value);
-            } else {
-                formData2.append(name, value);
-            }
-        }
-        return [ formData1, formData2 ];
+    json(data = {}) {
+        const result = formData.call(this, ...arguments);
+        return result[0];
     }
 
-    json(data = {}, callback = null) {
-        if (arguments.length) {
-            Object.keys(data).forEach(key => {
-                wwwFormPathSerializeCallback(key, data[key], (_wwwFormPath, _value) => {
-                    if (!callback || callback(_wwwFormPath, _value, _isTypeObject(_value))) {
-                        this.append(_wwwFormPath, _value);
-                    }
-                }, value => !formDataType(value));
-            });
-            return;
-        }
-        var jsonBuild; // We'll dynamically determine if this should be an array or an object
-        for (var [ name, value ] of this.entries()) {
-            if (!jsonBuild) {
-                jsonBuild = _isNumeric(_before(name, '[')) ? [] : {};
-            }
-            wwwFormSet(jsonBuild, name, value);
+    static compat(formData) {
+        if (formData instanceof this) return formData;
+        if (formData instanceof FormData) {
+            return Object.setPrototypeOf(formData, new this);
         }
-        return jsonBuild;
     }
 
-}
-
-export default xFormData;
-
-export const formDataType = (value, list = null) => {
-    if (!_isTypeObject(value)) {
-        return;
-    }
-    const toStringTag = value[Symbol.toStringTag];
-    return (list || [
-        'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer', 'Blob', 'File', 'FormData', 'Stream'
-    ]).reduce((_toStringTag, type) => _toStringTag || (toStringTag === type ? type : null), null);
-};
+}

package/src/runtime-pi/xHeaders.js

@@ -1,22 +1,15 @@
 
-/**
- * @imports
- */
-import { _after, _beforeLast } from "@webqit/util/str/index.js";
-import { _isString, _getType, _isObject, _isFunction } from "@webqit/util/js/index.js";
-import { _isTypeObject } from '@webqit/util/js/index.js';
-
 /**
  * The xHeaders Mixin
  */
-const xHeaders = whatwagHeaders => class extends whatwagHeaders {
+export default class xHeaders extends Headers {
 
     // construct
     constructor(definition = {}) {
         const cookies = definition.cookies;
         delete definition.cookies;
         // -----------------        
-        if (definition instanceof whatwagHeaders) {
+        if (definition instanceof Headers) {
             // It's another Headers instance
             super(definition);
         } else {
@@ -140,8 +133,6 @@ const xHeaders = whatwagHeaders => class extends whatwagHeaders {
 
 }
 
-export default xHeaders;
-
 function getAllPropertyDescriptors(obj) {
     if (!obj) {
         return Object.create(null);

package/src/runtime-pi/xRequest.js

@@ -2,46 +2,47 @@
 /**
  * @imports
  */
-import xHttpMessage, { encodeBody } from './xHttpMessage.js';
+import { formatMessage } from './util-http.js';
+import mxHttpMessage from './xxHttpMessage.js';
+import xRequestHeaders from './xRequestHeaders.js';
 
 /**
  * The xRequest Mixin
  */
-const xRequest = (whatwagRequest, Headers, FormData, Blob) => class extends xHttpMessage(whatwagRequest, Headers, FormData) {
+export default class xRequest extends mxHttpMessage(Request, xRequestHeaders) {
         
     constructor(input, init = {}) {
-        init = { ...init };
-        let bodyAttrs = {};
-        if ((input instanceof whatwagRequest)) {
+        let meta = {};
+        if ((input instanceof Request)) {
             // On method change...
             if (init.method && input.method !== init.method.toUpperCase() && [ 'GET', 'HEAD' ].includes(init.method.toUpperCase())) {
                 // Body must not be inherited.
                 input = input.url;
+                init = { ...init };
                 // We should now simply copy attributes
                 [ 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity' ].forEach(attr => {
-                    if (!(attr in init)) {
-                        init[attr] = input[attr];
-                    }
+                    if (!(attr in init)) { init[attr] = input[attr]; }
                 });
-            } else {
-                // Inherit bodyAttrs
-                bodyAttrs = input.bodyAttrs || {};
             }
         }
-        // Init can contain "already-parsed request content"
-        if (('body' in init)) {
-            bodyAttrs = encodeBody(init.body, FormData, Blob);
-            init.body = bodyAttrs.body;
-        }
         let isNavigateMode;
-        if (init.mode === 'navigate') {
-            isNavigateMode = true;
-            init = { ...init };
-            delete init.mode;
+        if (!(init instanceof Request)) {
+            // Init can contain "already-parsed request content"
+            if (('body' in init) && !(init.headers instanceof Headers)) {
+                const [ body, headers, type ] = formatMessage(init.body);
+                meta = { type, body: init.body };
+                init = { ...init, body, headers: { ...headers, ...(init.headers || {}), } };
+            }
+            if (init.mode === 'navigate') {
+                isNavigateMode = true;
+                init = { ...init };
+                delete init.mode;
+            }
         }
-        super(input, init, bodyAttrs);
+        // ---------------
+        super(input, init, meta);
+        // ---------------
         if (isNavigateMode) {
-            // Through the backdoor
             this.attrs.mode = 'navigate';
         }
     }
@@ -50,16 +51,11 @@ const xRequest = (whatwagRequest, Headers, FormData, Blob) => class extends xHtt
         return 'mode' in this.attrs ? this.attrs.mode : super.mode;
     }
 
-    get cache() {
-        return 'cache' in this.attrs ? this.attrs.cache : super.cache;
-    }
-
-    get destination() {
-        return 'destination' in this.attrs ? this.attrs.destination : super.destination;
-    }
-
-    get referrer() {
-        return 'referrer' in this.attrs ? this.attrs.referrer : super.referrer;
+    static compat(request) {
+        if (request instanceof this) return request;
+        if (request instanceof Request) {
+            return Object.setPrototypeOf(request, new this);
+        }
     }
 
     static async rip(request) {
@@ -72,13 +68,4 @@ const xRequest = (whatwagRequest, Headers, FormData, Blob) => class extends xHtt
         return [ request.url, requestInit ];
     }
 
-    static compat(request) {
-        if (request instanceof this) return request;
-        if (request instanceof whatwagRequest) {
-            return Object.setPrototypeOf(request, new this);
-        }
-    }
-
-};
-
-export default xRequest;
+}

package/src/runtime-pi/xRequestHeaders.js

@@ -4,34 +4,14 @@
  */
 import { _after } from "@webqit/util/str/index.js";
 import { _from as _arrFrom } from "@webqit/util/arr/index.js";
-import { _getType, _isObject } from "@webqit/util/js/index.js";
-import { wwwFormUnserialize } from './util.js';
+import { params } from './util-url.js';
 import xHeaders from './xHeaders.js';
 import xCookies from './Cookies.js';
 
-/**
- * Cookies
- */
-class Cookies extends xCookies {
-
-    parse(str) {
-        return wwwFormUnserialize(str, {}, ';');
-    }
-    
-    parseEntry(str) {
-        return str.trim().split('=');
-    }
-
-    stringifyEntry(cookieBody) {
-        return cookieBody;
-    }
-
-}
-
 /**
  * The xHeaders Mixin
  */
-const xRequestHeaders = NativeHeaders => class extends xHeaders(NativeHeaders) {
+export default class xRequestHeaders extends xHeaders {
     
     get cookieHeaderName() {
         return 'Cookie';
@@ -109,4 +89,21 @@ const xRequestHeaders = NativeHeaders => class extends xHeaders(NativeHeaders) {
 
 }
 
-export default xRequestHeaders;
+/**
+ * Cookies
+ */
+class Cookies extends xCookies {
+
+    parse(str) {
+        return params.parse(str, ';');
+    }
+    
+    parseEntry(str) {
+        return str.trim().split('=');
+    }
+
+    stringifyEntry(cookieBody) {
+        return cookieBody;
+    }
+
+}

package/src/runtime-pi/xResponse.js

@@ -2,31 +2,37 @@
 /**
  * @imports
  */
-import xHttpMessage, { encodeBody } from './xHttpMessage.js';
+import { formatMessage } from './util-http.js';
+import mxHttpMessage from './xxHttpMessage.js';
+import xResponseHeaders from './xResponseHeaders.js';
 
 /**
  * The xResponse Mixin
  */
-const xResponse = (whatwagResponse, Headers, FormData, Blob) => class extends xHttpMessage(whatwagResponse, Headers, FormData) {
+export default class xResponse extends mxHttpMessage(Response, xResponseHeaders) {
 
     // construct
-    constructor(body = null, init = {}) {
-        let bodyAttrs = {}, isResponseInput;
+    constructor(body = undefined, init = {}) {
+        let meta = {}, isResponseInput;
         if (arguments.length) {
-            if (body instanceof whatwagResponse) {
+            if (body instanceof Response) {
                 isResponseInput = body;
                 // Inherit init
                 init = { status: body.status, statusText: body.statusText, headers: body.headers, ...init };
                 if (body.status === 0) delete init.status;
-                // Inherit bodyAttrs and body
-                bodyAttrs = body.bodyAttrs || {};
+                // Inherit meta and body
+                meta = body.meta || {};
                 body = body.body;
-            } else {
-                bodyAttrs = encodeBody(body, FormData, Blob);
-                body = bodyAttrs.body;
+            } else if (!(init.headers instanceof Headers)) {
+                let headers, type, _body = body;
+                [ body, headers, type ] = formatMessage(body);
+                meta = { type, body: _body };
+                init = { ...init, headers: { ...headers, ...(init.headers || {}), } };
             }
         }
-        super(body, init, bodyAttrs);
+        // ---------------
+        super(body, init, meta);
+        // ---------------
         if (isResponseInput) {
             // Through the backdoor
             this.attrs.url = isResponseInput.url;
@@ -59,11 +65,9 @@ const xResponse = (whatwagResponse, Headers, FormData, Blob) => class extends xH
 
     static compat(response) {
         if (response instanceof this) return response;
-        if (response instanceof whatwagResponse) {
+        if (response instanceof Response) {
             return Object.setPrototypeOf(response, new this);
         }
     }
 
-};
-
-export default xResponse;
+}

package/src/runtime-pi/xResponseHeaders.js

@@ -4,53 +4,13 @@
  */
 import { _after, _beforeLast } from "@webqit/util/str/index.js";
 import { _isString, _getType, _isObject } from "@webqit/util/js/index.js";
-import _Headers from './xHeaders.js';
+import xHeaders from './xHeaders.js';
 import xCookies from './Cookies.js';
 
-/**
- * Cookies
- */
-class Cookies extends xCookies {
-
-    parse(cookieStr) {
-        const obj = {};
-        cookieStr && cookieStr.split(',').forEach(str => {
-            let [ cookieName, definition ] = this.parseEntry(str);
-            obj[cookieName] = definition;
-        });
-        return obj;
-    }
-
-    parseEntry(str) {
-        let [ cookieDefinition, attrsStr ] = str.split(';');
-        let [ cookieName, cookieValue ] = cookieDefinition.trim().split('=');
-        let attrs = { value: cookieValue, };
-        attrsStr && (attrsStr || '').split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
-            attrs[attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
-        });
-        return [ cookieName, attrs ];
-    }
-
-    stringifyEntry(cookieBody) {
-        if (_isObject(cookieBody)) {
-            let attrsArr = [ cookieBody.value ];
-            for (let attrName in cookieBody) {
-                if (attrName === 'value') continue;
-                let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
-                if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
-                attrsArr.push(cookieBody[attrName] === true ? _attrName : `${_attrName}=${cookieBody[attrName]}`);
-            }
-            cookieBody = attrsArr.join(';');
-        }
-        return cookieBody;
-    }
-
-}
-
 /**
  * The _Headers Mixin
  */
-const _ResponseHeaders = NativeHeaders => class extends _Headers(NativeHeaders) {
+export default class xResponseHeaders extends xHeaders {
 
     get cookieHeaderName() {
         return 'Set-Cookie';
@@ -116,4 +76,42 @@ const _ResponseHeaders = NativeHeaders => class extends _Headers(NativeHeaders)
 
 }
 
-export default _ResponseHeaders;
+/**
+ * Cookies
+ */
+class Cookies extends xCookies {
+
+    parse(cookieStr) {
+        const obj = {};
+        cookieStr && cookieStr.split(',').forEach(str => {
+            let [ cookieName, definition ] = this.parseEntry(str);
+            obj[cookieName] = definition;
+        });
+        return obj;
+    }
+
+    parseEntry(str) {
+        let [ cookieDefinition, attrsStr ] = str.split(';');
+        let [ cookieName, cookieValue ] = cookieDefinition.trim().split('=');
+        let attrs = { value: cookieValue, };
+        attrsStr && (attrsStr || '').split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
+            attrs[attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
+        });
+        return [ cookieName, attrs ];
+    }
+
+    stringifyEntry(cookieBody) {
+        if (_isObject(cookieBody)) {
+            let attrsArr = [ cookieBody.value ];
+            for (let attrName in cookieBody) {
+                if (attrName === 'value') continue;
+                let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
+                if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
+                attrsArr.push(cookieBody[attrName] === true ? _attrName : `${_attrName}=${cookieBody[attrName]}`);
+            }
+            cookieBody = attrsArr.join(';');
+        }
+        return cookieBody;
+    }
+
+}