@webqit/webflo 0.8.77 → 0.9.1

package/src/runtime-pi/server/whatwag.js

@@ -0,0 +1,35 @@
+
+/**
+ * @imports
+ */
+import { URL } from 'url';
+import { FormData, File, Blob } from 'formdata-node';
+import fetch, { Request, Response, Headers } from 'node-fetch';
+import { FormDataEncoder } from 'form-data-encoder';
+import { Readable } from "stream";
+
+/**
+ * The NavigationEvent class
+ */
+if (!Request.prototype.formData) {
+    Request.prototype.formData = async function() { return null }
+}
+if (!Response.prototype.formData) {
+    Response.prototype.formData = async function() { return null }
+}
+FormData.encode = formData => {
+    const encoder = new FormDataEncoder(formData);
+    return [ Readable.from(encoder.encode()), encoder.headers ];
+};
+
+export {
+    URL,
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    Readable as ReadableStream,
+    File,
+    Blob,
+}

package/src/{runtime/_FormData.js → runtime-pi/xFormData.js}

@@ -9,7 +9,7 @@ import { wwwFormSet, wwwFormPathSerializeCallback } from './util.js';
  /**
   * The _Headers Mixin
   */
-const _FormData = NativeFormData => class extends NativeFormData {
+const xFormData = whatwagFormData => class extends whatwagFormData {
 
     tee(callback = null) {
         const formData1 = new this.constructor, formData2 = new this.constructor;
@@ -47,7 +47,7 @@ const _FormData = NativeFormData => class extends NativeFormData {
 
 }
 
-export default _FormData;
+export default xFormData;
 
 export const formDataType = (value, list = null) => {
     if (!_isTypeObject(value)) {

package/src/{runtime/_Headers.js → runtime-pi/xHeaders.js}

@@ -7,13 +7,13 @@ import { _isString, _getType, _isObject, _isFunction } from "@webqit/util/js/ind
 import { _isTypeObject } from '@webqit/util/js/index.js';
 
 /**
- * The _Headers Mixin
+ * The xHeaders Mixin
  */
-const _Headers = NativeHeaders => class extends NativeHeaders {
+const xHeaders = whatwagHeaders => class extends whatwagHeaders {
 
     // construct
     constructor(definition = {}) {
-        if (definition instanceof NativeHeaders) {
+        if (definition instanceof whatwagHeaders) {
             // It's another Headers instance
             super(definition);
         } else {
@@ -73,7 +73,7 @@ const _Headers = NativeHeaders => class extends NativeHeaders {
 
 }
 
-export default _Headers;
+export default xHeaders;
 
 function getAllPropertyDescriptors(obj) {
     if (!obj) {

package/src/runtime-pi/xHttpEvent.js

@@ -0,0 +1,93 @@
+
+/**
+ * @imports
+ */
+import { _isEmpty } from '@webqit/util/js/index.js';
+
+/**
+ * The xHttpEvent Mixin
+ */
+const xHttpEvent = (Request, Response, URL) => {
+
+    const HttpEvent = class {
+
+        /**
+         * Initializes a new HttpEvent instance.
+         * 
+         * @param Request       _request 
+         * @param Object        _detail
+         * @param Object        _sessionFactory
+         */
+        constructor(_request, _detail, _sessionFactory) {
+            this._request = _request;
+            this._detail = _detail || {};
+            this._sessionFactory = _sessionFactory;
+            // -------
+            this.Request = Request;
+            this.Response = Response;
+            this.URL = URL;
+            // -------
+            this.port = {
+                listeners: [],
+                post(message) { 
+                    const promises = this.listeners.map(listener => listener(message))
+                        .filter(returnValue => returnValue instanceof Promise);
+                    if (process.length) return Promise.all(promises);
+                },
+                listen(listener) { this.listeners.push(listener); },
+            }
+        }
+
+        // url
+        get url() {
+            if (!this._url) {
+                this._url = new this.URL(this._request.url);
+            }
+            return this._url;
+        }
+
+        // request
+        get request() {
+            return this._request;
+        }
+
+        // detail
+        get detail() {
+            return this._detail;
+        }
+
+        // Session
+        get session() {
+            if (!this._session) {
+                this._session = this.sessionFactory().get();
+            }
+            return this._session;
+        }
+
+        // Session factory
+        sessionFactory(...args) {
+            return this._sessionFactory(...args);
+        }
+
+        // RDR
+        retarget(url, init = {}) {
+            var request;
+            if (url instanceof Request) {
+                if (!_isEmpty(init)) {
+                    request = new Request(url, init);
+                } else {
+                    request = url;
+                }
+            } else {
+                request = new Request(this._request, init);
+                request.attrs.url = `${this.url.origin}${url}`;
+                request.attrs.referrer = this.request.url;
+            }            
+            return new HttpEvent(request, this.detail);
+        }
+
+    }
+    return HttpEvent;
+}
+
+export default xHttpEvent;

package/src/runtime-pi/xHttpMessage.js

@@ -0,0 +1,179 @@
+
+/**
+ * @imports
+ */
+import { _isArray, _isEmpty, _isNumber, _isObject, _isPlainArray, _isPlainObject, _isString } from '@webqit/util/js/index.js';
+import { formDataType } from './xFormData.js';
+
+/**
+ * The _Request Mixin
+ */
+const xHttpMessage = (whatwagHttpMessage, Headers, FormData) => {
+    const HttpMessage = class extends whatwagHttpMessage {
+        
+        constructor(input, init, bodyAttrs) {
+            if (('headers' in init) && !(init.headers instanceof Headers)) {
+                init = { ...init };
+                init.headers = new Headers(init.headers);
+                arguments[1] = init;
+            }
+            if (_isEmpty(init)) {
+                super(input);
+            } else {
+                super(input, init);
+            }
+            this._headers = init.headers;
+            if (bodyAttrs.headers) {
+                this.headers.json(bodyAttrs.headers);
+            }
+            let attrs = {};
+            Object.defineProperty(this, 'attrs', { get: () => attrs });
+            Object.defineProperty(this, 'bodyAttrs', { get: () => bodyAttrs });
+        }
+
+        clone() {
+            return new this.constructor(super.clone());
+        }
+
+        get headers() {
+            if (!this._headers) {
+                this._headers = new Headers(super.headers);
+            }
+            return this._headers;
+        }
+
+        get attrs() {
+            return this.attrs;
+        }
+
+        get url() {
+            return 'url' in this.attrs ? this.attrs.url : super.url;
+        }
+
+        async arrayBuffer() {
+            if (this.bodyAttrs.arrayBuffer) {
+                return this.bodyAttrs.arrayBuffer;
+            }
+            return super.arrayBuffer();
+        }
+
+        async blob() {
+            if (this.bodyAttrs.blob) {
+                return this.bodyAttrs.blob;
+            }
+            return super.blob();
+        }
+
+        async formData() {
+            if (this.bodyAttrs.formData) {
+                return this.bodyAttrs.formData;
+            }
+            const formData = await super.formData();
+            formData.tee = FormData.prototype.tee.bind(formData);
+            formData.json = FormData.prototype.json.bind(formData);
+            return formData;
+        }
+
+        async json() {
+            if (this.bodyAttrs.json) {
+                return this.bodyAttrs.json;
+            }
+            return super.json();
+        }
+
+        async text() {
+            if (this.bodyAttrs.text) {
+                return this.bodyAttrs.text;
+            }
+            return super.text();
+        }
+                
+        // Resolve
+        resolve(force = false) {
+            if (!this.bodyAttrs.resolved || force) {
+                this.bodyAttrs.resolved = new Promise(async (resolve, reject) => {
+                    var messageInstance = this, resolved, contentType = messageInstance.headers.get('content-type') || '';
+                    var type = contentType === 'application/json' || this.bodyAttrs.json ? 'json' : (
+                        contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/') || this.bodyAttrs.formData ? 'formData' : (
+                            contentType === 'text/plain' ? 'plain' : 'other'
+                        )
+                    );
+                    try {
+                        if (type === 'formData') {
+                            resolved = (await messageInstance.formData()).json();
+                        } else {
+                            resolved = type === 'json' ? await messageInstance.json() : (
+                                type === 'plain' ? await messageInstance.text() : messageInstance.body
+                            );
+                        }
+                        resolve(resolved);
+                    } catch(e) {
+                        reject(e);
+                    }
+                });
+            }
+            return this.bodyAttrs.resolved;
+        }
+
+    };
+    // ----------
+    HttpMessage.Headers = Headers;
+    // ----------
+    return HttpMessage;
+}
+
+export default xHttpMessage;
+export function encodeBody(body, FormData, Blob) {
+    const detailsObj = { body, input: body };
+    const encodeFormData = (detailsObj, formData) => {
+        if (!FormData.encode) return;
+        let [ body, headers ] = FormData.encode(formData);
+        detailsObj.body = body;
+        detailsObj.headers = headers;
+    }
+    if (_isString(body) || _isNumber(body)) {
+        detailsObj.inputType = 'text';
+        detailsObj.text = body;
+        detailsObj.headers = {
+            contentLength: (body + '').length,
+        };
+        return detailsObj;
+    }
+    detailsObj.inputType = formDataType(body);
+    if ([ 'Blob', 'File' ].includes(detailsObj.inputType)) {
+        detailsObj.blob = body;
+        detailsObj.headers = {
+            contentType: body.type,
+            contentLength: body.size,
+        };
+    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(detailsObj.inputType)) {
+        detailsObj.arrayBuffer = body;
+        detailsObj.headers = {
+            contentLength: body.byteLength,
+        };
+    } else if (detailsObj.inputType === 'FormData') {
+        detailsObj.formData = body;
+        encodeFormData(detailsObj, body);
+    } else if ((_isObject(body) && _isPlainObject(body)) || (_isArray(body) && _isPlainArray(body))) {
+        detailsObj.inputType = 'object';
+        // Deserialize object while detecting if multipart
+        var hasBlobs, formData = new FormData;
+        formData.json(body, (path, value, objectType) => {
+            hasBlobs = hasBlobs || objectType;
+            return true;
+        });
+        if (hasBlobs) {
+            detailsObj.formData = formData;
+            encodeFormData(detailsObj, formData);
+        } else {
+            detailsObj.json = body;
+            detailsObj.body = JSON.stringify(body);
+            detailsObj.headers = {
+                contentType: 'application/json',
+                contentLength: (new Blob([ detailsObj.body ])).size, // Buffer.byteLength(detailsObj.body, 'utf8') isn't cross-environment
+            };
+        }
+        detailsObj.resolved = body;
+    }
+    return detailsObj;
+}

package/src/runtime-pi/xRequest.js

@@ -0,0 +1,67 @@
+
+/**
+ * @imports
+ */
+import xHttpMessage, { encodeBody } from './xHttpMessage.js';
+
+/**
+ * The xRequest Mixin
+ */
+const xRequest = (whatwagRequest, Headers, FormData, Blob) => class extends xHttpMessage(whatwagRequest, Headers, FormData) {
+        
+    constructor(input, init = {}) {
+        init = { ...init };
+        let bodyAttrs = {};
+        if ((input instanceof whatwagRequest)) {
+            // 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;
+                // We should now simply copy attributes
+                [ 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity' ].forEach(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;
+        }
+        super(input, init, bodyAttrs);
+        if (isNavigateMode) {
+            // Through the backdoor
+            this.attrs.mode = 'navigate';
+        }
+    }
+
+    get mode() {
+        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;
+    }
+
+};
+
+export default xRequest;

package/src/runtime-pi/xRequestHeaders.js

@@ -0,0 +1,95 @@
+
+/**
+ * @imports
+ */
+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, wwwFormSerialize } from './util.js';
+import xHeaders from './xHeaders.js';
+
+/**
+ * The xHeaders Mixin
+ */
+const xRequestHeaders = NativeHeaders => class extends xHeaders(NativeHeaders) {
+
+    set accept(value) {
+        return this.set('Accept', value);
+    }
+
+    get accept() {
+        const accept = this.get('Accept');
+        const list = accept && accept.split(',').map(a => (a = a.trim().split(';').map(a => a.trim()), [a.shift(), parseFloat((a.pop() || '1').replace('q=', ''))]))
+            .sort((a, b) => a[1] > b[1] ? -1 : 1) || [];
+        return {
+            match(mime) {
+                mime = (mime + '').split('/');
+                return list.reduce((prev, entry) => prev || (
+                    (entry = entry[0].split('/')) && [0, 1].every(i => ((mime[i] === entry[i]) || mime[i] === '*' || entry[i] === '*'))
+                ), false);
+            },
+            toString() {
+                return accept;
+            }
+        };
+    }
+
+    set cookies(cookieJar) {
+        if (!_isObject(cookieJar)) {
+            throw new Error(`Cookies must be of type object. Received type: ${_getType(cookieJar)}.`);
+        }
+        this.set('Cookie', wwwFormSerialize(cookieJar, ';'));
+        this._cookies = null;
+        return true;
+    }
+
+    get cookies() {
+        if (!this._cookies) {
+            this._cookies = wwwFormUnserialize(this.get('cookie'), {}, ';');
+        }
+        return this._cookies;
+    }
+
+    set range(value) {
+        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);
+        });
+        return this.set('Range', rangeArr.join(', '));
+    }
+
+    get range() {
+        const value = this.get('Range');
+        if (!value) return;
+        const rangeArr = _after(value, 'bytes=').split(',').map(rangeStr => {
+            let range = rangeStr.trim().split('-');
+            range[0] = range[0] ? parseInt(range[0], 10) : undefined;
+            if (range[1]) {
+                range[1] = parseInt(range[1], 10);
+            }
+            range.clamp = max => {
+                if (range[1] > max - 1 || range[1] === undefined) {
+                    range[1] = max - 1;
+                }
+                if (range[0] === undefined) range[0] = range[1] ? max - range[1] - 1 : 0;
+            };
+            return range;
+        });
+        return rangeArr;
+    }
+
+    set cors(value) {
+        return this.set('Access-Control-Allow-Origin', value === true ? '*' : (value === false ? '' : value));
+    }
+
+    get cors() {
+        return this.get('Access-Control-Allow-Origin');
+    }
+
+}
+
+export default xRequestHeaders;

package/src/runtime-pi/xResponse.js

@@ -0,0 +1,62 @@
+
+/**
+ * @imports
+ */
+import xHttpMessage, { encodeBody } from './xHttpMessage.js';
+
+/**
+ * The xResponse Mixin
+ */
+const xResponse = (whatwagResponse, Headers, FormData, Blob) => class extends xHttpMessage(whatwagResponse, Headers, FormData) {
+
+    // construct
+    constructor(body = null, init = {}) {
+        let bodyAttrs = {}, isResponseInput;
+        if (arguments.length) {
+            if (body instanceof whatwagResponse) {
+                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 || {};
+                body = body.body;
+            } else {
+                bodyAttrs = encodeBody(body, FormData, Blob);
+                body = bodyAttrs.body;
+            }
+        }
+        super(body, init, bodyAttrs);
+        if (isResponseInput) {
+            // Through the backdoor
+            this.attrs.url = isResponseInput.url;
+            this.attrs.ok = isResponseInput.ok;
+            this.attrs.status = isResponseInput.status; // In case it was earlier deleted
+            this.attrs.type = isResponseInput.type;
+            this.attrs.redirected = isResponseInput.redirected;
+        }
+    }
+
+    get ok() {
+        return 'ok' in this.attrs ? this.attrs.ok : super.ok;
+    }
+
+    get status() {
+        return 'status' in this.attrs ? this.attrs.status : super.status;
+    }
+
+    get statusText() {
+        return 'statusText' in this.attrs ? this.attrs.statusText : super.statusText;
+    }
+
+    get type() {
+        return 'type' in this.attrs ? this.attrs.type : super.type;
+    }
+
+    get redirected() {
+        return 'redirected' in this.attrs ? this.attrs.redirected : super.redirected;
+    }
+
+};
+
+export default xResponse;

package/src/{runtime/_ResponseHeaders.js → runtime-pi/xResponseHeaders.js}

@@ -4,13 +4,49 @@
  */
 import { _after, _beforeLast } from "@webqit/util/str/index.js";
 import { _isString, _getType, _isObject } from "@webqit/util/js/index.js";
-import _Headers from './_Headers.js';
+import _Headers from './xHeaders.js';
 
 /**
  * The _Headers Mixin
  */
 const _ResponseHeaders = NativeHeaders => class extends _Headers(NativeHeaders) {
 
+    set cookies(cookieJar) {
+        if (!_isObject(cookieJar)) {
+            throw new Error(`The "cookies" response directive cannot be of type: ${_getType(cookieJar)}`);
+        }
+        for (let cookieName in cookieJar) {
+            let cookieBody = cookieJar[cookieName];
+            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('; ');
+            } 
+            this.append('Set-Cookie', `${cookieName}=${cookieBody}`);
+        }
+        return true;
+    }
+
+    get cookies() {
+        const cookiesStr = this.get('Set-Cookie');
+        return cookiesStr && cookiesStr.split(',').reduce((cookieJar, str) => {
+            let [ cookieDefinition, attrsStr ] = str.split(';');
+            let [ cookieName, cookieValue ] = cookieDefinition.trim().split('=');
+            cookieJar[cookieName] = { value: cookieValue, };
+            if (attrsStr) {
+                (attrsStr || '').split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
+                    cookieJar[cookieName][attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
+                });
+            }
+            return cookieJar;
+        }, {});
+    }
+
     set contentRange(value) {
         if (Array.isArray(value)) {
             if ((value.length === 2 && !value[0].includes('-')) || value.length < 2) {
@@ -18,28 +54,12 @@ const _ResponseHeaders = NativeHeaders => class extends _Headers(NativeHeaders)
             }
             return this.set('Content-Range', `bytes ${value.join('/')}`);
         }
-        if (!this.has('Accept-Ranges')) {
-            this.set('Accept-Ranges', 'bytes');
-        }
         return this.set('Content-Range', value);
     }
 
     get contentRange() {
         const value = this.get('Content-Range');
-        if (!value) return;
-        return _after(value, 'bytes ').split('/');
-    }
-
-    set cookies(cookieStr) {
-        if (!_isObject(cookieJar)) {
-            throw new Error(`The "cookies" response directive does not support the type: ${_getType(cookieStr)}`);
-        }
-        this.set('Set-Cookie', cookieStr);
-        return true;
-    }
-
-    get cookies() {
-        return this.get('Set-Cookie');
+        return value && _after(value, 'bytes ').split('/');
     }
 
     set cors(value) {

package/src/{runtime/_URL.js → runtime-pi/xURL.js}

@@ -8,11 +8,11 @@ import { wwwFormUnserialize, wwwFormSerialize } from './util.js';
 
 /**
  * ---------------------------
- * The _URL Mixin
+ * The xURL Mixin
  * ---------------------------
  */
-const _URL = NativeURL => {
-	const URL = class extends NativeURL {
+const xURL = whatwagURL => {
+	const URL = class extends whatwagURL {
 		
 		// constructor
 		constructor(...args) {
@@ -108,4 +108,4 @@ var _strictEven = (a, b) => {
 	return a === b;
 };
 
-export default _URL;
+export default xURL;

package/src/runtime-pi/xfetch.js

@@ -0,0 +1,7 @@
+
+/**
+ * The xfetch Mixin
+ */
+const xfetch = whatwagFetch => whatwagFetch;
+
+export default xfetch;