@webqit/webflo 0.8.45 → 0.8.49

package/src/modules/_MessageStream.js

@@ -0,0 +1,191 @@
+
+/**
+ * @imports
+ */
+import { _isArray, _isEmpty, _isNumber, _isObject, _isPlainArray, _isPlainObject, _isString } from '@webqit/util/js/index.js';
+import { formDataType } from './_FormData.js';
+
+/**
+ * The _Request Mixin
+ */
+const _MessageStream = (NativeMessageStream, Headers, FormData) => {
+    const MessageStream = class extends NativeMessageStream {
+        
+        constructor(input, init = {}) {
+            var _proxy = {}, _meta = {};
+            if ((('headers' in init) && !(init instanceof Headers)) || ('_proxy' in init) || ('meta' in init)) {
+                init = { ...init };
+                if (('headers' in init) && !(init instanceof Headers)) {
+                    init.headers = new Headers(init.headers);
+                }
+                if (('_proxy' in init)) {
+                    _proxy = init._proxy;
+                    delete init._proxy;
+                }
+                if (('meta' in init)) {
+                    _meta = init.meta;
+                    delete init.meta;
+                }
+                arguments[1] = init;
+            }
+            super(...arguments);
+            this._proxy = _proxy;
+            this._meta = _meta;
+        }
+
+        clone() {
+            const clone = new this.constructor(super.clone());
+            clone._proxy = this._proxy;
+            clone._headers = this._headers;
+            clone._typedDataCache = this._typedDataCache;
+            clone._meta = this._meta;
+            return clone;
+        }
+
+        get url() {
+            return 'url' in this._proxy ? this._proxy.url : super.url;
+        }
+
+        get headers() {
+            if (!this._headers) {
+                this._headers = new Headers(super.headers);
+            }
+            return this._headers;
+        }
+
+        get original() {
+            return this._typedDataCache.original;
+        }
+
+        get originalType() {
+            return this._typedDataCache.originalType;
+        }
+
+        get meta() {
+            return this._meta || {};
+        }
+
+        async arrayBuffer() {
+            if (this._typedDataCache.arrayBuffer) {
+                return this._typedDataCache.arrayBuffer;
+            }
+            return super.arrayBuffer();
+        }
+
+        async blob() {
+            if (this._typedDataCache.blob) {
+                return this._typedDataCache.blob;
+            }
+            return super.blob();
+        }
+
+        async formData() {
+            if (this._typedDataCache.formData) {
+                return this._typedDataCache.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._typedDataCache.json) {
+                return this._typedDataCache.json;
+            }
+            return super.json();
+        }
+
+        async text() {
+            if (this._typedDataCache.text) {
+                return this._typedDataCache.text;
+            }
+            return super.text();
+        }
+                
+        // Payload
+        jsonBuild(force = false) {
+            if (!this._typedDataCache.jsonBuild || force) {
+                this._typedDataCache.jsonBuild = new Promise(async resolve => {
+                    var request = this, jsonBuild, contentType = request.headers.get('content-type') || '';
+                    var type = contentType === 'application/json' || this._typedDataCache.json ? 'json' : (
+                        contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/') || this._typedDataCache.formData || (!contentType && !['get'].includes((request.method || '').toLowerCase())) ? 'formData' : (
+                            contentType === 'text/plain' ? 'plain' : 'other'
+                        )
+                    );
+                    if (type === 'formData') {
+                        jsonBuild = (await request.formData()).json();
+                    } else {
+                        jsonBuild = type === 'json' ? await request.json() : (
+                            type === 'plain' ? await request.text() : request.body
+                        );
+                    }
+                    resolve(jsonBuild);
+                });
+            }
+            return this._typedDataCache.jsonBuild;
+        }
+
+    };
+    // ----------
+    MessageStream.Headers = Headers;
+    // ----------
+    return MessageStream;
+}
+
+export default _MessageStream;
+
+export function encodeBody(body, globals) {
+    const detailsObj = { body, original: body };
+    if (_isString(body) || _isNumber(body)) {
+        detailsObj.originalType = 'text';
+        detailsObj.text = body;
+        detailsObj.headers = {
+            contentLength: (body + '').length,
+        };
+        return detailsObj;
+    }
+    detailsObj.originalType = formDataType(body);
+    if ([ 'Blob', 'File' ].includes(detailsObj.originalType)) {
+        detailsObj.blob = body;
+        detailsObj.headers = {
+            contentType: body.type,
+            contentLength: body.size,
+        };
+    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(detailsObj.originalType)) {
+        detailsObj.arrayBuffer = body;
+        detailsObj.headers = {
+            contentLength: body.byteLength,
+        };
+    } else if (detailsObj.originalType === 'FormData') {
+        detailsObj.formData = body;
+        encodeFormData(detailsObj, body, globals);
+    } else if ((_isObject(body) && _isPlainObject(body)) || (_isArray(body) && _isPlainArray(body))) {
+        // Deserialize object while detecting if multipart
+        var hasBlobs, formData = new globals.FormData;
+        formData.json(body, (path, value, objectType) => {
+            hasBlobs = hasBlobs || objectType;
+            return true;
+        });
+        if (hasBlobs) {
+            detailsObj.formData = formData;
+            encodeFormData(detailsObj, formData, globals);
+        } else {
+            detailsObj.json = body;
+            detailsObj.body = JSON.stringify(body);
+            detailsObj.headers = {
+                contentType: 'application/json',
+                contentLength: Buffer.byteLength(detailsObj.body, 'utf8'), // Buffer.from(string).length
+            };
+        }
+        detailsObj.jsonBuild = body;
+    }
+    return detailsObj;
+}
+
+const encodeFormData = (detailsObj, formData, globals) => {
+    if (!globals.FormDataEncoder || !globals.ReadableStream) return;
+    const encoder = new globals.FormDataEncoder(formData);
+    detailsObj.body = globals.ReadableStream.from(encoder.encode());
+    detailsObj.headers = encoder.headers;
+};

package/src/modules/_NavigationEvent.js

@@ -0,0 +1,89 @@
+
+/**
+ * @imports
+ */
+import _URL from './_URL.js';
+import _Request from "./_Request.js";
+import _Response from "./_Response.js";
+import _FormData from "./_FormData.js";
+import { _isEmpty } from '@webqit/util/js/index.js';
+
+/**
+ * The _NavigationEvent Mixin
+ */
+const _NavigationEvent = globals => {
+    // ----------
+    const URL = _URL(globals.URL);
+    const Request = _Request(globals);
+    const Response = _Response(globals);
+    // ----------
+    const NavigationEvent = class {
+
+        /**
+         * Initializes a new NavigationEvent instance.
+         * 
+         * @param Request       request 
+         * @param Object        sessionStore 
+         */
+        constructor(_request, _session = null) {
+            this._request = _request;
+            this._session = _session;
+            // -------
+            this.URL = URL;
+            // -------
+            this.Request = Request;
+            this.Request.sourceEvent = this; 
+            // -------
+            this.Response = Response;
+            this.Response.sourceEvent = this; 
+            // -------
+            this.globals = globals;
+        }
+
+        // url
+        get url() {
+            if (!this._url) {
+                this._url = new URL(this._request.url);
+            }
+            return this._url;
+        }
+
+        // request
+        get request() {
+            return this._request;
+        }
+
+        // session
+        get session() {
+            return this._session;
+        }
+
+        // RDR
+        retarget(url, init = {}) {
+            var request;
+            if (url instanceof NavigationEvent.Request) {
+                if (!_isEmpty(init)) {
+                    request = new NavigationEvent.Request(url, init);
+                } else {
+                    request = url;
+                }
+            } else {
+                init = { _proxy: {}, ...init };
+                init._proxy.url = `${this.url.origin}${url}`;
+                init._proxy.referrer = this.request.url;
+                request = new NavigationEvent.Request(this._request, init);
+            }            
+            return new NavigationEvent(request, this._session);
+        }
+
+    }
+    // ----------
+    NavigationEvent.URL = URL;
+    NavigationEvent.Request = Request;
+    NavigationEvent.Response = Response;
+    NavigationEvent.globals = globals;
+    // ----------
+    return NavigationEvent;
+}
+
+export default _NavigationEvent;

package/src/modules/_Request.js

@@ -0,0 +1,61 @@
+
+/**
+ * @imports
+ */
+import { _isEmpty } from '@webqit/util/js/index.js';
+import _MessageStream, { encodeBody } from './_MessageStream.js';
+import _RequestHeaders from './_RequestHeaders.js';
+
+/**
+ * The _Request Mixin
+ */
+const _Request = globals => class extends _MessageStream(globals.Request, _RequestHeaders(globals.Headers), globals.FormData) {
+        
+    constructor(input, init = {}) {
+        var _typedDataCache = {};
+        if (input instanceof globals.Request) {
+            init = { ...init };
+            init._proxy = { ...(input._proxy || {}), ...(init._proxy || {}) };
+            if (input._typedDataCache) {
+                _typedDataCache = input._typedDataCache;
+            }
+            if (init.method && input.method !== init.method.toUpperCase() && [ 'GET', 'HEAD' ].includes(init.method.toUpperCase())) {
+                // Body must not inherited. We should now simply copy attributes
+                input = input.url;
+                [ 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity' ].forEach(attr => {
+                    if (!(attr in init)) {
+                        init[attr] = input[attr];
+                    }
+                });
+            }
+        }
+        // Init can contain "already-parsed request content"
+        if (('body' in init)) {
+            init = { ...init };
+            if (('body' in init)) {
+                _typedDataCache = encodeBody(init.body, globals);
+                init.body = _typedDataCache.body;
+            }
+        }
+        if (!_isEmpty(init)) {
+            super(input, init);
+        } else {
+            super(input);
+        }
+        this._typedDataCache = _typedDataCache;
+        if (this._typedDataCache.headers) {
+            this.headers.json(this._typedDataCache.headers);
+        }
+    }
+
+    get destination() {
+        return 'destination' in this._proxy ? this._proxy.destination : super.destination;
+    }
+
+    get referrer() {
+        return 'referrer' in this._proxy ? this._proxy.referrer : super.referrer;
+    }
+
+};
+
+export default _Request;

package/src/modules/_RequestHeaders.js

@@ -0,0 +1,72 @@
+
+/**
+ * @imports
+ */
+import { _after } from "@webqit/util/str/index.js";
+import _Headers from './_Headers.js';
+import { wwwFormUnserialize } from './util.js';
+
+/**
+ * The _Headers Mixin
+ */
+const _RequestHeaders = NativeHeaders => class extends _Headers(NativeHeaders) {
+
+    set accept(value) {
+        return this.set('Accept', value);
+    }
+
+    get accept() {
+        const list = (this.get('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);
+            }
+        };
+    }
+
+    set cookies(cookies) {
+        this.set('Cookie', cookies);
+        return true;
+    }
+
+    get cookies() {
+        if (!this._cookies) {
+            this._cookies = wwwFormUnserialize(this.get('cookie'), {}, ';');
+        }
+        return this._cookies;
+    }
+
+    set cors(value) {
+        return this.set('Access-Control-Allow-Origin', value === true ? '*' : (value === false ? '' : value));
+    }
+
+    get cors() {
+        return this.get('Access-Control-Allow-Origin');
+    }
+
+    set range(value) {
+        return this.set('Range', Array.isArray(value) ? `bytes=${value.join('-')}` : value);
+    }
+
+    get range() {
+        const value = this.get('Range');
+        if (!value) return;
+        const range = _after(value, 'bytes=').split('-');
+        range[0] = range[0] ? parseInt(range[0], 10) : 0;
+        range[1] = range[1] ? parseInt(range[1], 10) : 0;
+        range.clamp = max => {
+            if (range[1] > max - 1) {
+                range[1] = max - 1;
+            }
+        };
+        return range;
+    }
+
+}
+
+export default _RequestHeaders;

package/src/modules/_Response.js

@@ -0,0 +1,56 @@
+
+/**
+ * @imports
+ */
+import { _isEmpty, _isUndefined } from '@webqit/util/js/index.js';
+import _MessageStream, { encodeBody } from './_MessageStream.js';
+import _ResponseHeaders from './_ResponseHeaders.js';
+
+/**
+ * The _Response Mixin
+ */
+const _Response = globals => class extends _MessageStream(globals.Response, _ResponseHeaders(globals.Headers), globals.FormData) {
+
+    // construct
+    constructor(body = null, init = {}) {
+        var _proxy = {}, _meta = {}, _typedDataCache = {};
+        if (arguments.length) {
+            _typedDataCache = encodeBody(body, globals);
+            body = _typedDataCache.body;
+        }
+        // Init can contain "already-parsed request content"
+        if (('_proxy' in init) || ('meta' in init)) {
+            init = { ...init };
+            if (('_proxy' in init)) {
+                _proxy = init._proxy;
+                delete init._proxy;
+            }
+            if (('meta' in init)) {
+                _meta = init.meta;
+                delete init.meta;
+            }
+        }
+        if (!_isEmpty(init)) {
+            super(body, init);
+        } else {
+            super(body);
+        }
+        this._proxy = _proxy;
+        this._meta = _meta;
+        this._typedDataCache = _typedDataCache;
+        if (this._typedDataCache.headers) {
+            this.headers.json(this._typedDataCache.headers);
+        }
+    }
+
+    get ok() {
+        return 'ok' in this._proxy ? this._proxy.ok : super.ok;
+    }
+
+    get redirected() {
+        return 'redirected' in this._proxy ? this._proxy.redirected : super.redirected;
+    }
+
+};
+
+export default _Response;

package/src/modules/_ResponseHeaders.js

@@ -0,0 +1,81 @@
+
+/**
+ * @imports
+ */
+import { _after, _beforeLast } from "@webqit/util/str/index.js";
+import { _isString, _getType, _isObject } from "@webqit/util/js/index.js";
+import _Headers from './_Headers.js';
+
+/**
+ * The _Headers Mixin
+ */
+const _ResponseHeaders = NativeHeaders => class extends _Headers(NativeHeaders) {
+
+    set contentRange(value) {
+        if (Array.isArray(value)) {
+            if ((value.length === 2 && !value[0].includes('-')) || value.length < 2) {
+                throw new Error(`A Content-Range array must be in the format: [ 'start-end', 'total' ]`);
+            }
+            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');
+    }
+
+    set cors(value) {
+        return this.set('Access-Control-Allow-Origin', value === true ? '*' : (value === false ? '' : value));
+    }
+
+    get cors() {
+        return this.get('Access-Control-Allow-Origin');
+    }
+
+    set attachment(value) {
+        value = value === true ? 'attachment' : (value === false ? 'inline' : value);
+        if (!_isString(value)) {
+            throw new Error(`The "download" response directive does not support the type: ${_getType(value)}`);
+        }
+        if (![ 'attachment', 'inline' ].includes(value)) {
+            value = `attachment; filename="${value}"`;
+        }
+        return this.set('Content-Disposition', value);
+    }
+
+    get attachment() {
+        var value = (this.get('Content-Disposition') || '').trim();
+        value = value === 'attachment' ? true : (
+            value === 'inline' ? false : _after(_beforeLast(value, '"'), 'filename="')
+        );
+        return value;
+    }
+
+    get redirect() {
+        return this.get('Location');
+    }
+
+    set redirect(value) {
+        return this.set('Location', value);
+    }
+}
+
+export default _ResponseHeaders;

package/src/modules/_URL.js

@@ -0,0 +1,111 @@
+
+/**
+ * @imports
+ */
+import { Observer } from '@webqit/pseudo-browser/index2.js';
+import _isArray from '@webqit/util/js/isArray.js';
+import _isObject from '@webqit/util/js/isObject.js';
+import { wwwFormUnserialize, wwwFormSerialize } from './util.js';
+
+/**
+ * ---------------------------
+ * The _URL Mixin
+ * ---------------------------
+ */
+const _URL = NativeURL => {
+	const URL = class extends NativeURL {
+		
+		// constructor
+		constructor(...args) {
+			super(...args);
+			var query = wwwFormUnserialize(this.search);
+			const updateSearch = query => {
+				// "query" was updated. So we update "search"
+				var search = wwwFormSerialize(query);
+				search = search ? '?' + search : '';
+				if (search !== this.search) {
+					this.search = search;
+				}
+			};
+			this.__query = {
+				value: query,
+				proxy: new Proxy(query, {
+					set(t, n, v) {
+						t[n] = v;
+						updateSearch(t);
+						return true;
+					},
+					deleteProperty(t, n) {
+						delete t[n];
+						updateSearch(t);
+						return true;
+					}
+				})
+			};
+		}
+
+		// Set search
+		set search(value) {
+			super.search = value;
+			// "search" was updated. So we update "query"
+			var query = wwwFormUnserialize(value);
+			if (!_strictEven(query, this.query)) {
+				this.query = query;
+			}
+		}
+
+		// Get search
+		get search() {
+			return super.search;
+		}
+
+		// Get query
+		get query() {
+			return this.__query.proxy;
+		}
+
+	};
+	// ----------
+    URL.Observable = class extends URL {
+	
+		constructor() {
+			super(...arguments);
+			Observer.accessorize(this, [
+				'protocol', 
+				'username',
+				'password',
+				'host',
+				'hostname',
+				'port',
+				'origin',
+				'pathname',
+				'search',
+				'query',
+				'hash',
+				'href',
+			]);
+		}
+	
+	};
+    // ----------
+	return URL;
+}
+
+/**
+ * ---------------------------
+ * Helpers
+ * ---------------------------
+ */
+var _strictEven = (a, b) => {
+	if (_isObject(a) && _isObject(b)) {
+		return _strictEven(Object.keys(a), Object.keys(b)) 
+		&& _strictEven(Object.values(a), Object.values(b));
+	}
+	if (_isArray(a) && _isArray(b)) {
+		return a.length === b.length 
+		&& a.reduce((recieved, item, i) => recieved && item === b[i], true);
+	}
+	return a === b;
+};
+
+export default _URL;

package/src/modules/client/Cache.js

@@ -0,0 +1,38 @@
+
+/**
+ * @imports
+ */
+
+export function syncToCache(name, data) {
+    const blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });
+    return caches.open(name)
+        .then(cache => cache.put('http://session.temp', new Response(blob)));
+}
+
+export function syncFromCache(name, del = false) {
+    return caches.open(name)
+        .then(cache => cache.match('http://session.temp')
+        .then(response => response ? response.json() : null))
+        .then(async data => (del ? await caches.delete(name) : null, data)).catch(e => null);
+}
+
+/**
+const sessionData = Object.keys(clientNavigationEvent.session)
+    .reduce((obj, key) => (obj[key] = clientNavigationEvent.session[key], obj), {});
+await syncToCache('$session', sessionData);
+*/
+/**
+response.finally(async () => {
+    // Sync session data from cache that may have been exposed by service-worker routers
+    const sessionData = await syncFromCache('$session', true);
+    if (!sessionData) return;
+    const keysInCache = Object.keys(sessionData);
+    _unique(Object.keys(clientNavigationEvent.session).concat(keysInCache)).forEach(key => {
+        if (!keysInCache.includes(key)) {
+            delete clientNavigationEvent.session[key];
+        } else {
+            clientNavigationEvent.session[key] = sessionData[key];
+        }
+    });
+});
+*/