@webqit/webflo 0.11.61-0 → 1.0.0

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,130 +1,99 @@
-
-/**
- * @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 {
-
-	/**
-	 * 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;
-        const $runtime = this.cx.runtime;
-
-        // ----------------
-        // The loop
-        // ----------------
-        const next = async function(thisTick) {
-            const thisContext = { runtime: $runtime };
-            if (!thisTick.trail || thisTick.trail.length < thisTick.destination.length) {
-                thisTick = await $this.readTick(thisTick);
-                // -------------
-                thisContext.pathname = `/${thisTick.trail.join('/')}`;
-                thisContext.stepname = thisTick.trail[thisTick.trail.length - 1];
-                $this.finalizeHandlerContext(thisContext, thisTick);
-                // -------------
-                if (thisTick.exports) {
-                    // Broadcast any hints exported by handler
-                    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) {
-                        // -------------
-                        // Dynamic response
-                        // -------------
-                        const _next = async (..._args) => {
-                            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) {
-                                    _request = _args[1];
-                                    _url = _request.url;
-                                } else if (!_isString(_url)) {
-                                    throw new Error('Router redirect url must be a string!');
-                                }
-                                let newDestination = _url.startsWith('/') ? _url : $this.pathJoin(`/${thisTick.trail.join('/')}`, _url);
-                                if (newDestination.startsWith('../')) {
-                                    throw new Error('Router redirect cannot traverse beyond the routing directory! (' + _url + ' >> ' + newDestination + ')');
-                                }
-                                if (requestInit.method) {
-                                    nextTick.method = requestInit.method;
-                                    if (_isArray(requestInit.method)) {
-                                        requestInit.method = requestInit.method[0];
-                                    }
-                                }
-                                if (_request) {
-                                    nextTick.event = await thisTick.event.with(newDestination, _request, requestInit);
-                                } else {
-                                    nextTick.event = await thisTick.event.with(newDestination, requestInit);
-                                }
-                                nextTick.source = thisTick.destination.join('/');
-                                nextTick.destination = newDestination.split('?').shift().split('/').map(a => a.trim()).filter(a => a);
-                                nextTick.trail = _args[1].startsWith('/') ? [] : thisTick.trail.reduce((_commonRoot, _seg, i) => _commonRoot.length === i && _seg === nextTick.destination[i] ? _commonRoot.concat(_seg) : _commonRoot, []);
-                                nextTick.trailOnFile = thisTick.trailOnFile.slice(0, nextTick.trail.length);
-                            }
-                            return next(nextTick);
-                        };
-                        // -------------
-                        const nextPathname = thisTick.destination.slice(thisTick.trail.length);
-                        _next.pathname = nextPathname.join('/');
-                        _next.stepname = nextPathname[0];
-                        // -------------
-                        return await handler.call(thisContext, thisTick.event, thisTick.arg, _next/*next*/, remoteFetch);
-                    }
-                    // Handler not found but exports found
-                    return next(thisTick);
-                } else if ((thisTick.currentSegmentOnFile || {}).dirExists) {
-                    // Exports not found but directory found
-                    return next(thisTick);
-                }
-            }
-            // -------------
-            // Local file
-            // -------------
-            if (_default) {
-                return await _default.call(thisContext, thisTick.event, thisTick.arg, remoteFetch);
-            }
-        };
-        
-        return next({
-            destination: this.path,
-            event,
-            method,
-            arg,
-         });
-
-    }
-
-}
+import { _isString, _isFunction, _isArray } from '@webqit/util/js/index.js';
+import { _from as _arrFrom } from '@webqit/util/arr/index.js';
+
+export class WebfloRouter {
+
+	constructor(cx, path = []) {
+        this.cx = cx;
+        this.path = _isArray(path) ? path : (path + '').split('/').filter(a => a);
+    }
+
+    async route(method, event, arg, _default, remoteFetch = null) {
+
+        const $this = this;
+        const $runtime = this.cx.runtime;
+
+        // ----------------
+        // The loop
+        // ----------------
+        const next = async function(thisTick) {
+            const thisContext = { runtime: $runtime };
+            if (!thisTick.trail || thisTick.trail.length < thisTick.destination.length) {
+                thisTick = await $this.readTick(thisTick);
+                // -------------
+                thisContext.pathname = `/${thisTick.trail.join('/')}`;
+                thisContext.stepname = thisTick.trail[thisTick.trail.length - 1];
+                $this.finalizeHandlerContext(thisContext, thisTick);
+                // -------------
+                if (thisTick.exports) {
+                    // Broadcast any hints exported by handler
+                    //@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) {
+                        // -------------
+                        // Dynamic response
+                        // -------------
+                        const _next = async (..._args) => {
+                            const nextTick = { ...thisTick, arg: _args[0] };
+                            if (_args.length > 1) {
+                                let _url = _args[1], _request, requestInit = { ...(_args[2] || {}) };
+                                if (_args[1] instanceof Request) {
+                                    _request = _args[1];
+                                    _url = _request.url;
+                                } else if (!_isString(_url)) {
+                                    throw new Error('Router redirect url must be a string!');
+                                }
+                                let newDestination = _url.startsWith('/') ? _url : $this.pathJoin(`/${thisTick.trail.join('/')}`, _url);
+                                if (newDestination.startsWith('../')) {
+                                    throw new Error('Router redirect cannot traverse beyond the routing directory! (' + _url + ' >> ' + newDestination + ')');
+                                }
+                                if (requestInit.method) {
+                                    nextTick.method = requestInit.method;
+                                    if (_isArray(requestInit.method)) {
+                                        requestInit.method = requestInit.method[0];
+                                    }
+                                }
+                                if (_request) {
+                                    nextTick.event = await thisTick.event.with(newDestination, _request, requestInit);
+                                } else {
+                                    nextTick.event = await thisTick.event.with(newDestination, requestInit);
+                                }
+                                nextTick.source = thisTick.destination.join('/');
+                                nextTick.destination = newDestination.split('?').shift().split('/').map(a => a.trim()).filter(a => a);
+                                nextTick.trail = _args[1].startsWith('/') ? [] : thisTick.trail.reduce((_commonRoot, _seg, i) => _commonRoot.length === i && _seg === nextTick.destination[i] ? _commonRoot.concat(_seg) : _commonRoot, []);
+                                nextTick.trailOnFile = thisTick.trailOnFile.slice(0, nextTick.trail.length);
+                            }
+                            return next(nextTick);
+                        };
+                        // -------------
+                        const nextPathname = thisTick.destination.slice(thisTick.trail.length);
+                        _next.pathname = nextPathname.join('/');
+                        _next.stepname = nextPathname[0];
+                        // -------------
+                        return await handler.call(thisContext, thisTick.event, thisTick.arg, _next/*next*/, remoteFetch);
+                    }
+                    // Handler not found but exports found
+                    return next(thisTick);
+                } else if ((thisTick.currentSegmentOnFile || {}).dirExists) {
+                    // Exports not found but directory found
+                    return next(thisTick);
+                }
+            }
+            // -------------
+            // Local file
+            // -------------
+            if (_default) {
+                return await _default.call(thisContext, thisTick.event, thisTick.arg, remoteFetch);
+            }
+        };
+        
+        return next({
+            destination: this.path,
+            event,
+            method,
+            arg,
+         });
+
+    }
+}

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 @@
-
-/**
- * @imports
- */
-import _Contex from '../../Context.js';
-
-export default class Context extends _Contex {}
+import { AbstractContext } from '../../AbstractContext.js';
+
+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();
+    }
+}