@webqit/webflo 0.11.61 → 1.0.0

package/src/runtime-pi/WebfloCookieStorage.js

@@ -0,0 +1,27 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { renderCookieObj } from './util-http.js';
+import { WebfloStorage } from './WebfloStorage.js';
+
+export class WebfloCookieStorage extends WebfloStorage {
+    constructor(request, iterable = []) {
+        iterable = [...iterable].map(([key, value]) => [key, !_isObject(value) ? { name: key, value } : value]);
+        super(request, null, iterable);
+        this.saveOriginals();
+    }
+
+    render() {
+        return this.getAdded().map((key) => renderCookieObj({ name: key, ...this.get(key, true) })).concat(
+            this.getDeleted().map((key) => renderCookieObj({ name: key, value: '', maxAge: 0 }))
+        );
+    }
+
+    set(key, value) {
+        if (!_isObject(value)) { value = { name: key, value }; }
+        return super.set(key, value);
+    }
+
+    get(key, withDetail = false) {
+        if (!withDetail) return super.get(key)?.value;
+        return super.get(key);
+    }
+}

package/src/runtime-pi/WebfloEventTarget.js

@@ -0,0 +1,39 @@
+export class WebfloEventTarget extends EventTarget {
+
+    #parentNode;
+    #params;
+    #listenersRegistry = new Set;
+
+    get parentNode() { return this.#parentNode; }
+    get params() { return this.#params; }
+    get length() { return this.#listenersRegistry.size; }
+
+    constructor(parentNode, params = {}) {
+        super();
+        this.#parentNode = parentNode;
+        this.#params = params;
+    }
+
+    setParent(parentNode) {
+        this.#parentNode = parentNode;
+    }
+
+    dispatchEvent(event) {
+        const returnValue = super.dispatchEvent(event);
+        if (this.#parentNode instanceof EventTarget && !event.defaultPrevented && !event.propagationStopped) {
+            this.#parentNode.dispatchEvent(event);
+        }
+        return returnValue;
+    }
+
+    addEventListener(...args) {
+        this.#listenersRegistry.add(args);
+        return super.addEventListener(...args);
+    }
+
+    $destroy() {
+        for (const listenerArgs of this.#listenersRegistry) {
+            this.removeEventListener(...listenerArgs);
+        }
+    }
+}

package/src/runtime-pi/WebfloMessageEvent.js

@@ -0,0 +1,58 @@
+
+export class WebfloMessageEvent extends Event {
+
+    #originalTarget;
+    get originalTarget() { return this.#originalTarget; }
+
+    get runtime() {
+        let parentNode = this.#originalTarget;
+        do {
+            if (parentNode.runtime) return parentNode.runtime;
+        } while (parentNode = parentNode.parentNode)
+    }
+
+    #data;
+    get data() { return this.#data; }
+
+    #ports = [];
+    get ports() { return this.#ports; }
+
+    constructor(originalTarget, messageType, message, ports) {
+        super(messageType);
+        this.#originalTarget = originalTarget;
+        this.#data = message;
+        this.#ports = ports;
+    }
+
+    #immediatePropagationStopped = false;
+    get immediatePropagationStopped() { return this.#immediatePropagationStopped; }
+
+    stopImmediatePropagation() {
+        this.#immediatePropagationStopped = true;
+        this.#propagationStopped = true;
+        super.stopImmediatePropagation();
+    }
+
+    #propagationStopped = false;
+    get propagationStopped() { return this.#propagationStopped; }
+
+    stopPropagation() {
+        this.#propagationStopped = true;
+        super.stopPropagation();
+    }
+
+    #defaultPrevented = false;
+    get defaultPrevented() { return this.#defaultPrevented; }
+
+    preventDefault() {
+        this.#defaultPrevented = true;
+        super.preventDefault();
+    }
+
+    respondWith(data, transferOrOptions = []) {
+        for (const port of this.ports) {
+            port.postMessage(data, transferOrOptions);
+        }
+        return !!this.ports.length;
+    }
+}

package/src/runtime-pi/WebfloMessagingAPI.js

@@ -0,0 +1,69 @@
+import { WebfloEventTarget } from './WebfloEventTarget.js';
+
+export class WebfloMessagingAPI extends WebfloEventTarget {
+
+    #isConnected = false;
+    isConnected() { return this.#isConnected; }
+
+    #isSending = false;
+    isMessaging() { return this.#isSending || !!this.length; }
+
+    #hooks = new Set;
+    on(eventName, callback, { once = false } = {}) {
+        if (eventName === 'connected' && this.#isConnected) {
+            callback();
+            if (once) {
+                return;
+            }
+        }
+        const hook = { eventName, callback, once };
+        this.#hooks.add(hook);
+        return () => this.#hooks.delete(hook);
+    }
+
+    $emit(eventName, arg) {
+        if (eventName === 'connected') {
+            this.#isConnected = true;
+        }
+        for (const hook of this.#hooks) {
+            if (hook.eventName !== eventName) continue;
+            hook.callback(arg);
+            if (hook.once) {
+                this.#hooks.delete(hook);
+            }
+        }
+    }
+
+    /* ----------------- */
+
+    postMessage(data, transferOrOptions = []) {
+        this.#isSending = true;
+    }
+
+    postRequest(message, callback, options = {}) {
+        const { signal, once, ...$options } = options;
+        const messageChannel = new MessageChannel;
+        messageChannel.port1.addEventListener('message', (e) => callback(e), {
+            signal,
+            once
+        });
+        messageChannel.port1.start();
+        return this.postMessage(message, { ...$options, transfer: [ messageChannel.port2 ].concat($options.transfer || []) });
+    }
+
+    handleMessages(type, listener, options = {}) {
+        this.addEventListener(type, listener, options);
+        return () => {
+            this.removeEventListener(type, listener, options);
+        };
+    }
+
+    handleRequests(type, listener, options = {}) {
+        return this.handleMessages(type, async (e) => {
+            const response = await listener(e);
+            for (const p of e.ports) {
+                p.postMessage(response);
+            }
+        }, options);
+    }
+}

package/src/runtime-pi/{Router.js → WebfloRouter.js}

@@ -1,43 +1,13 @@
-
-/**
- * @imports
- */
 import { _isString, _isFunction, _isArray } from '@webqit/util/js/index.js';
 import { _from as _arrFrom } from '@webqit/util/arr/index.js';
 
-/**
- * ---------------------------
- * The Router class
- * ---------------------------
- */
-			
-export default class Router {
+export class WebfloRouter {
 
-	/**
-	 * Constructs a new Router instance
-     * over route definitions.
-	 *
-	 * @param Context	        cx
-	 * @param String|Array	    path
-	 *
-	 * @return void
-	 */
 	constructor(cx, path = []) {
         this.cx = cx;
         this.path = _isArray(path) ? path : (path + '').split('/').filter(a => a);
     }
 
-    /**
-     * Performs dynamic routing
-     * 
-     * @param array|string      method
-     * @param Object            event
-     * @param any               arg
-     * @param function          _default
-     * @param function          remoteFetch
-     * 
-     * @return object
-     */
     async route(method, event, arg, _default, remoteFetch = null) {
 
         const $this = this;
@@ -57,7 +27,7 @@ export default class Router {
                 // -------------
                 if (thisTick.exports) {
                     // Broadcast any hints exported by handler
-                    if (thisTick.exports.hints) { await event.port.post({ ...thisTick.exports.hints, $type: 'handler:hints' }); }
+                    //@obsolete if (thisTick.exports.hints) { await event.port.post({ ...thisTick.exports.hints, $type: 'handler:hints' }); }
                     const methods = _arrFrom(thisTick.method).map(m => m === 'default' ? m : m.toUpperCase());
                     const handler = _isFunction(thisTick.exports) && methods.includes('default') ? thisTick.exports : methods.reduce((_handler, name) => _handler || thisTick.exports[name], null);
                     if (handler) {
@@ -68,7 +38,7 @@ export default class Router {
                             const nextTick = { ...thisTick, arg: _args[0] };
                             if (_args.length > 1) {
                                 let _url = _args[1], _request, requestInit = { ...(_args[2] || {}) };
-                                if (_args[1] instanceof nextTick.event.Request) {
+                                if (_args[1] instanceof Request) {
                                     _request = _args[1];
                                     _url = _request.url;
                                 } else if (!_isString(_url)) {
@@ -126,5 +96,4 @@ export default class Router {
          });
 
     }
-
 }

package/src/runtime-pi/WebfloRuntime.js

@@ -0,0 +1,52 @@
+import { _isObject } from '@webqit/util/js/index.js';
+
+export class WebfloRuntime {
+
+    async dispatch(httpEvent, context, crossLayerFetch) {
+        // Exec routing
+        const router = new this.constructor.Router(this.cx, httpEvent.url.pathname);
+        const route = async () => {
+            return await router.route([httpEvent.request.method, 'default'], httpEvent, context, async (event) => {
+                return crossLayerFetch(event);
+            }, (...args) => this.remoteFetch(...args));
+        };
+        try {
+            // Route for response
+            return await (this.cx.middlewares || []).concat(route).reverse().reduce((next, fn) => {
+                return () => fn.call(this.cx, httpEvent, router, next);
+            }, null)();
+            
+        } catch (e) {
+            console.error(e);
+            return new Response(null, { status: 500, statusText: e.message });
+        }
+    }
+
+    async normalizeResponse(httpEvent, response, forceCommit = false) {
+        // Normalize response
+        if (!(response instanceof Response)) {
+            response = typeof response === 'undefined'
+                ? new Response(null, { status: 404 })
+                : Response.create(response);
+        }
+        // Commit data
+        for (const storage of [httpEvent.cookies, httpEvent.session, httpEvent.storage]) {
+            await storage?.commit?.(response, forceCommit);
+        }
+        return response;
+    }
+
+    async execPush(clientPort, data) {
+        if (data instanceof Response) {
+            if ([301, 302, 303, 307, 308].includes(data.status) && data.headers.has('Location')) {
+                clientPort.postMessage(data.headers.get('Location'), { messageType: 'redirect' });
+                return;
+            }
+            data = await data.parse();
+        }
+        if (!_isObject(data)) {
+            throw new Error('Response not serializable');
+        }
+        clientPort.postMessage(data, { messageType: 'response' });
+    }
+}

package/src/runtime-pi/WebfloStorage.js

@@ -0,0 +1,109 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { _even } from '@webqit/util/obj/index.js';
+
+export class WebfloStorage extends Map {
+    
+    #request;
+    #session;
+
+    constructor(request, session, iterable = []) {
+        super(iterable);
+        this.#request = request;
+        this.#session = session === true ? this : session;
+    }
+    
+    #originals;
+    saveOriginals() { this.#originals = new Map(this); }
+
+    getDeleted() {
+        if (!this.#originals) return [];
+        return [...this.#originals.keys()].filter((k) => {
+            return !this.has(k);
+        });
+    }
+
+    getAdded() {
+        if (!this.#originals) return [...this.keys()];
+        return [...new Set([...this.keys(), ...this.#originals.keys()])].filter((k) => {
+            return !this.#originals.has(k) || (this.has(k) && ((a, b) => _isObject(a) && _isObject(b) ? !_even(a, b) : a !== b)(this.get(k, true), this.#originals.get(k)));
+        });
+    }
+
+    commit() {
+        this.saveOriginals();
+    }
+
+    #handlers = new Map;
+    #reverseHandlers = new Map;
+    defineHandler(attr, ...handlers) {
+        let registry = this.#handlers;
+        if (handlers[0] === false) {
+            registry = this.#reverseHandlers;
+            handlers.shift();
+        }
+        const $handlers = [];
+        for (let handler of handlers) {
+            if (typeof handler === 'function') {
+                handler = { callback: handler };
+            } else if (typeof handler === 'string') {
+                handler = { url: handler };
+            } else if (typeof handler?.callback !== 'function' && typeof handler?.url !== 'string') {
+                throw new Error(`Handler must be either an URL or a function or an object specifying either an URL (handler.url) or a function (handler.callback)`);
+            }
+            $handlers.push(handler);
+        }
+        registry.set(attr, $handlers);
+    }
+
+    defineReverseHandler(attr, ...handlers) {
+        return this.defineHandler(attr, false, ...handlers);
+    }
+
+    getHandlers() { return this.#handlers; }
+
+    getReverseHandlers() { return this.#reverseHandlers; }
+
+    async require(attrs, callback = null, noNulls = false) {
+        const entries = [];
+        main: for await (const attr of [].concat(attrs)) {
+            if (!this.has(attr) || (noNulls && [undefined, null].includes(this.get(attr)))) {
+                const handlers = this.#handlers.get(attr);
+                if (!handlers) {
+                    throw new Error(`No handler defined for the user attribute: ${attr}`);
+                }
+                for (let i = 0; i < handlers.length; i ++) {
+                    const handler = handlers[i];
+                    if (handler.callback) {
+                        const returnValue = await handler.callback(this, attr);
+                        if (returnValue instanceof Response) {
+                            return returnValue;
+                        }
+                        if ((typeof returnValue === 'undefined' || (noNulls && returnValue === null)) && i < handlers.length - 1) {
+                            continue;
+                        }
+                        entries.push(returnValue);
+                        continue main;
+                    }
+                    const urlRewrite = new URL(handler.url, this.#request.url);
+                    if (!urlRewrite.searchParams.has('success-redirect')) {
+                        urlRewrite.searchParams.set('success-redirect', this.#request.url.replace(urlRewrite.origin, ''));
+                    }
+                    if (handler.message) {
+                        if (!this.#session) {
+                            throw new Error('Storage type does not support redirect messages');
+                        }
+                        const messageID = (0 | Math.random() * 9e6).toString(36);
+                        urlRewrite.searchParams.set('redirect-message', messageID);
+                        this.#session.set(`redirect-message:${messageID}`, { status: { type: handler.type || 'info', message: handler.message }});
+                    }
+                    return new Response(null, { status: 302, headers: {
+                        Location: urlRewrite
+                    }});
+                }
+            }
+            entries.push(this.get(attr));
+        }
+        if (callback) return await callback(...entries);
+        return entries;
+    }
+}

package/src/runtime-pi/client/ClientMessaging.js

@@ -0,0 +1,5 @@
+import { MessagingOverChannel } from '../MessagingOverChannel.js';
+
+export class ClientMessaging extends MessagingOverChannel {
+    get runtime() { return this.parentNode; }
+}

package/src/runtime-pi/client/Context.js

@@ -1,7 +1,3 @@
+import { AbstractContext } from '../../AbstractContext.js';
 
-/**
- * @imports
- */
-import _Context from '../../Context.js';
-
-export default class Context extends _Context {}
+export class Context extends AbstractContext {}

package/src/runtime-pi/client/CookieStorage.js

@@ -0,0 +1,17 @@
+import { WebfloCookieStorage } from '../WebfloCookieStorage.js';
+
+export class CookieStorage extends WebfloCookieStorage {
+    static create(request) {
+        return new this(
+            request,
+            document.cookie.split(';').map((c) => c.split('=').map((s) => s.trim()))
+        );
+    }
+
+    commit(response) {
+        for (const cookieStr of this.render()) {
+            document.cookie = cookieStr;
+        }
+        super.commit();
+    }
+}

package/src/runtime-pi/client/Router.js

@@ -1,17 +1,7 @@
-
-/**
- * @imports
- */
 import { path as Path } from '../util-url.js';
-import _Router from '../Router.js';
-
-/**
- * ---------------------------
- * The Router class
- * ---------------------------
- */
+import { WebfloRouter } from '../WebfloRouter.js';
 			
-export default class Router extends _Router {
+export class Router extends WebfloRouter {
 
     async readTick(thisTick) {
         thisTick = { ...thisTick };
@@ -45,4 +35,4 @@ export default class Router extends _Router {
     pathJoin(...args) {
         return Path.join(...args);
     }
-};
+}

package/src/runtime-pi/client/SessionStorage.js

@@ -0,0 +1,33 @@
+import { WebfloStorage } from '../WebfloStorage.js';
+
+export class SessionStorage extends WebfloStorage {
+    static get type() { return 'session'; }
+
+    static create(request) {
+        const keys = [];
+        const storeType = this.type === 'user' ? 'localStorage' : 'sessionStorage';
+		for(let i = 0; i < window[storeType].length; i ++){
+			keys.push(window[storeType].key(i));
+		};
+        const instance = new this(
+            request,
+            keys.map((key) => [key, window[storeType].getItem(key)])
+        );
+        return instance;
+    }
+
+    constructor(request, iterable) {
+        super(request, true, iterable);
+    }
+
+    commit() {
+        const storeType = this.constructor.type === 'user' ? 'localStorage' : 'sessionStorage';
+        for (const key of this.getAdded()) {
+            window[storeType].setItem(key, this.get(key));
+        }
+        for (const key of this.getDeleted()) {
+            window[storeType].removeItem(key);
+        }
+        super.commit();
+    }
+}

package/src/runtime-pi/client/Url.js

@@ -1,28 +1,11 @@
-
-/**
- * @imports
- */
 import { _with } from '@webqit/util/obj/index.js';
 import { _isArray, _isObject, _isTypeObject, _isString, _isEmpty } from '@webqit/util/js/index.js';
-import { Observer } from './Runtime.js';
 import { params } from '../util-url.js';
 
-/**
- * ---------------------------
- * The Url class
- * ---------------------------
- */
+const { Observer } = webqit;
 
-export default class Url {
+export class Url {
 
-	/**
-	 * Constructs a new Url instance.
-	 *
-     * @param object input
-     * @param object pathMappingScheme
-     * 
-	 * @return void
-	 */
 	constructor(input) {
         const Self = this.constructor;
 		// -----------------------
@@ -56,6 +39,9 @@ export default class Url {
 				// ----------
 				if (e.key === 'href' && e.related.length === 1) {
 					var urlObj = Self.parseUrl(e.value);
+					if (urlObj.pathname) {
+						urlObj.pathname = '/' + urlObj.pathname.split('/').filter(s => s.trim()).join('/');
+					}
 					delete urlObj.query;
 					delete urlObj.href;
 					onlyHrefChanged = true;
@@ -68,13 +54,27 @@ export default class Url {
 						urlObj.search = search;
 					}
 				}
-				if (e.key === 'search') {
+				if (e.key === 'search' && !e.related.includes('query')) {
 					// "search" was updated. So we update "query"
 					var query = Self.toQuery(urlObj.search || this.search); // Not e.value, as that might be a href value
 					if (!_strictEven(query, this.query)) {
 						urlObj.query = query;
 					}
 				}
+				if (e.key === 'pathname' && !e.related.includes('ancestorPathname')) {
+					// "pathname" was updated. So we update "ancestorPathname"
+					var ancestorPathname = (urlObj.pathname || this.pathname).replace(new RegExp('/[^/]+(?:/)?$'), '');
+					if (ancestorPathname !== this.ancestorPathname) {
+						urlObj.ancestorPathname = ancestorPathname;
+					}
+				}
+				if (e.key === 'ancestorPathname' && !e.related.includes('pathname')) {
+					// "ancestorPathname" was updated. So we update "pathname"
+					var pathname = '/' + (urlObj.ancestorPathname || this.ancestorPathname).split('/').filter(s => s).concat((urlObj.pathname || this.pathname).split('/').filter(s => s).pop()).join('/');
+					if (pathname !== this.pathname) {
+						urlObj.pathname = pathname;
+					}
+				}
 			}
 			if (!onlyHrefChanged) {
 				var fullOrigin = this.origin,
@@ -110,85 +110,37 @@ export default class Url {
         Observer.set(this, _isString(input) ? Self.parseUrl(input) : Url.copy(input));
 	}
 
-	/**
-	 * Converts the instance to string.
-	 *
-	 * @return string
-	 */
 	toString() {
         return this.href;
     }
     
-	/**
-	 * Creates an instance from parsing an URL string
-     * or from a regular object.
-	 *
-	 * @param string|object 	href
-	 *
-	 * @return Url
-	 */
 	static from(href) {
         return new this(_isObject(href) ? href : this.parseUrl(href));
 	}
 
-	/**
-	 * Copies URL properties off
-	 * the given object.
-	 *
-	 * @param object 			urlObj
-	 *
-	 * @return object
-	 */
 	static copy(urlObj) {
-		var url = urlProperties.reduce((obj, prop) => _with(obj, prop, urlObj[prop]), {});
+		var url = urlProperties.reduce((obj, prop) => _with(obj, prop, urlObj[prop] || ''), {});
 		if (!('query' in urlObj)) {
 			delete url.query;
 		}
 		return url;
 	}
 
-	/**
-	 * Parses an URL and returns its properties
-	 *
-	 * @param string			href
-	 *
-	 * @return object
-	 */
 	static parseUrl(href) {
-		var a = document.createElement('a');
-		a.href = href;
+		var a = new URL(href);
 		return this.copy(a);
 	}
 
-	/**
-	 * Parses the input search string into a named map
-	 *
-	 * @param string			search
-	 *
-	 * @return object
-	 */
 	static toQuery(search) {
 		return params.parse(search);
 	}
 
-	/**
-	 * Stringifies the input query to search string.
-	 *
-	 * @param object			query
-	 *
-	 * @return string
-	 */
 	static toSearch(query) {
 		var search = params.stringify(query);
 		return search ? '?' + search : '';
-	}}
+	}
+}
 
-/**
- * These are standard
- * and shouldnt'/can't be modified
- *
- * @array
- */
 const urlProperties = [
 	'protocol', 
 	'username',