@webqit/webflo 0.11.61-0 → 0.20.1

package/src/runtime-pi/client/worker/Runtime.js

@@ -1,269 +0,0 @@
-
-/**
- * @imports
- */
-import { _any } from '@webqit/util/arr/index.js';
-import { Observer } from '@webqit/oohtml-ssr/apis.js';
-import { pattern } from '../../util-url.js';
-import Workport from './Workport.js';
-import _Runtime from '../../Runtime.js';
-import xRequest from "../../xRequest.js";
-import xResponse from "../../xResponse.js";
-import xfetch from '../../xfetch.js';
-import HttpEvent from '../../HttpEvent.js';
-
-export {
-	HttpEvent,
-	Observer,
-}
-
-/**
- * ---------------------------
- * The Runtime Initializer
- * ---------------------------
- */
-
-export default class Runtime extends _Runtime {
-
-	/**
-     * Runtime
-     * 
-     * @param Object        cx
-     * @param Function      applicationInstance
-     * 
-     * @return void
-     */
-	constructor(cx, applicationInstance) {
-		super(cx, applicationInstance);
-        // ---------------
-        this.mockSessionStore = {};
-        // --------------		
-		// ONINSTALL
-		self.addEventListener('install', evt => {
-			if (this.cx.params.skip_waiting) { self.skipWaiting(); }
-			// Manage CACHE
-			if (this.cx.params.cache_name && (this.cx.params.cache_only_urls || []).length) {
-				// Add files to cache
-				evt.waitUntil( self.caches.open(this.cx.params.cache_name).then(cache => {
-					if (this.cx.logger) { this.cx.logger.log('[ServiceWorker] Pre-caching resources.'); }
-					const cache_only_urls = (this.cx.params.cache_only_urls || []).map(c => c.trim()).filter(c => c && !pattern(c, self.origin).isPattern());
-					return cache.addAll(cache_only_urls);
-				}) );
-			}
-		});
-
-		// -------------
-		// ONACTIVATE
-		self.addEventListener('activate', evt => {
-			evt.waitUntil( new Promise(async resolve => {
-				if (this.cx.params.skip_waiting) { await self.clients.claim(); }
-				// Manage CACHE
-				if (this.cx.params.cache_name) {
-					// Clear outdated CACHES
-					await self.caches.keys().then(keyList => {
-						return Promise.all(keyList.map(key => {
-							if (key !== this.cx.params.cache_name && key !== this.cx.params.cache_name + '_json') {
-								if (this.cx.logger) { this.cx.logger.log('[ServiceWorker] Removing old cache:', key); }
-								return self.caches.delete(key);
-							}
-						}));
-					}) 
-				}
-				resolve();
-			}) );
-		});
-
-		// ---------------
-        Observer.set(this, 'location', {});
-        Observer.set(this, 'network', {});
-        // ---------------
-		Observer.observe(this.network, es => {
-			//console.log('//////////', ...es.map(e => `${e.name}: ${e.value}`))
-		});
-
-		// -------------
-		// ONFETCH
-		self.addEventListener('fetch', event => {
-			// URL schemes that might arrive here but not supported; e.g.: chrome-extension://
-			if (!event.request.url.startsWith('http')) return;
-			event.respondWith((async evt => {
-				let requestingClient = await self.clients.get(evt.clientId);
-				this.workport.setCurrentClient(requestingClient);
-				const [ url, requestInit ] = await xRequest.rip(evt.request);
-				// Now, the following is key:
-				// The browser likes to use "force-cache" for "navigate" requests, when, e.g: re-entering your site with the back button
-				// Problem here, force-cache forces out JSON not HTML as per webflo's design.
-				// So, we detect this scenerio and avoid it.
-				if (requestInit.cache === 'force-cache'/* && evt.request.mode === 'navigate' - even webflo client init call also comes with that... needs investigation */) {
-					requestInit.cache = 'default';
-				}
-				return this.go(url, requestInit, { event: evt });
-			})(event));
-		});
-
-		// -------------
-		// Workport
-		const workport = new Workport();
-		Observer.set(this, 'workport', workport);
-
-		// -------------
-		// Initialize
-		(async () => {
-			if (!this.app.init) return;
-			const request = this.generateRequest('/');
-			const httpEvent = new HttpEvent(request, { srcType: 'initialization' }, (id = null, persistent = false) => this.getSession(httpEvent, id, persistent));
-			await this.app.init(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
-		})();
-		
-	}
-
-	/**
-     * Performs a request.
-     *
-     * @param object|string 	url
-     * @param object|Request	init
-     * @param object 			detail
-     *
-     * @return Response
-     */
-	async go(url, init = {}, detail = {}) {
-		// ------------
-        url = typeof url === 'string' ? new URL(url, self.location.origin) : url;
-		if (!(init instanceof Request) && !init.referrer) {
-			init = { referrer: this.location.href, ...init };
-		}
-        // ------------
-		// The request object
-		const request = this.generateRequest(url.href, init);
-		if (detail.event) { Object.defineProperty(detail.event, 'request', { value: request }); }
-		// The navigation event
-		const httpEvent = new HttpEvent(request, detail, (id = null, persistent = false) => this.getSession(httpEvent, id, persistent));
-		httpEvent.port.listen(message => {
-			if (message.$type === 'handler:hints' && message.session) {
-				// TODO: Sync session data from client
-				return Promise.resolve();
-			}
-		});
-		// Response
-		let response;
-		if (httpEvent.request.url.startsWith(self.origin)/* && httpEvent.request.mode === 'navigate'*/) {
-			response = await this.app.handle(httpEvent, ( ...args ) => this.remoteFetch( ...args ));
-		} else {
-			response = await this.remoteFetch(httpEvent.request);
-		}
-		const finalResponse = await this.handleResponse(httpEvent, response);
-        // Return value
-        return finalResponse;
-	}
-
-    // Generates request object
-    generateRequest(href, init = {}) {
-		const request = new xRequest(href, init);
-		return request;
-    }
-
-    // Generates session object
-    getSession(e, id = null, persistent = false) {
-		return {
-			get: () => this.mockSessionStore,
-			set: value => { this.mockSessionStore = value },
-		};
-	}
-
-	// Initiates remote fetch and sets the status
-	remoteFetch(request, ...args) {
-		if (arguments.length > 1) {
-			request = this.generateRequest(request, ...args);
-		}
-		const matchUrl = (patterns, url) => _any((patterns || []).map(p => p.trim()).filter(p => p), p => pattern(p, self.origin).test(url));
-		const execFetch = () => {
-			// network_first_urls
-			if (!this.cx.params.default_fetching_strategy || this.cx.params.default_fetching_strategy === 'network-first' || matchUrl(this.cx.params.network_first_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'network-first');
-				return this.networkFetch(request, { cacheFallback: true, cacheRefresh: true });
-			}
-			// cache_first_urls
-			if (this.cx.params.default_fetching_strategy === 'cache-first' || matchUrl(this.cx.params.cache_first_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'cache-first');
-				return this.cacheFetch(request, { networkFallback: true, cacheRefresh: true });
-			}
-			// network_only_urls
-			if (this.cx.params.default_fetching_strategy === 'network-only' || matchUrl(this.cx.params.network_only_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'network-only');
-				return this.networkFetch(request, { cacheFallback: false, cacheRefresh: false });
-			}
-			// cache_only_urls
-			if (this.cx.params.default_fetching_strategy === 'cache-only' || matchUrl(this.cx.params.cache_only_urls, request.url)) {
-				Observer.set(this.network, 'strategy', 'cache-only');
-				return this.cacheFetch(request, { networkFallback: false, cacheRefresh: false });
-			}
-		};
-		let response = execFetch(request);
-		// This catch() is NOT intended to handle failure of the fetch
-		response.catch(e => Observer.set(this.network, 'error', e.message));
-		// Return xResponse
-		return response.then(_response => xResponse.compat(_response));
-	}
-
-	// Caching strategy: network_first
-	networkFetch(request, params = {}) {
-		if (!params.cacheFallback) {
-			Observer.set(this.network, 'remote', true);
-			return xfetch(request);
-		}
-		return xfetch(request).then(response => {
-			if (params.cacheRefresh) this.refreshCache(request, response);
-			Observer.set(this.network, 'remote', true);
-			return response;
-		}).catch(() => this.getRequestCache(request).then(cache => {
-			Observer.set(this.network, 'cache', true);
-			return cache.match(request);
-		}));
-	}
-
-	// Caching strategy: cache_first
-	cacheFetch(request, params = {}) {
-		return this.getRequestCache(request).then(cache => cache.match(request).then(response => {
-			// Nothing cache, use network
-			if (!response && params.networkFallback) return this.networkFetch(request, { ...params, cacheFallback: false });
-			// Note: fetch, but for refreshing purposes only... not the returned response
-			if (response && params.cacheRefresh) this.networkFetch(request, { ...params, justRefreshing: true });
-			Observer.set(this.network, 'cache', true);
-			return response;
-		}));
-	}
-
-	// Caches response 
-	refreshCache(request, response) {
-		// Check if we received a valid response
-		if (request.method !== 'GET' || !response || response.status !== 200 || (response.type !== 'basic' && response.type !== 'cors')) {
-			return response;
-		}
-		// IMPORTANT: Clone the response. A response is a stream
-		// and because we want the browser to consume the response
-		// as well as the cache consuming the response, we need
-		// to clone it so we have two streams.
-		var responseToCache = response.clone();
-		this.getRequestCache(request).then(cache => {
-			Observer.set(this.network, 'cacheRefresh', true);
-			cache.put(request, responseToCache);
-		});
-		return response;
-	}
-
-	// Returns either the regular cache or a json-specific cache
-	getRequestCache(request) {
-		let cacheName = request.headers.get('Accept') === 'application/json'
-			? this.cx.params.cache_name + '_json' 
-			: this.cx.params.cache_name;
-		return self.caches.open(cacheName);
-	}
-
-	// Handles response object
-	handleResponse(e, response) {
-		if (!response && response !== 0) { response = new xResponse(null, { status: 404 }); }
-		else if (!(response instanceof xResponse)) { response = xResponse.compat(response); }
-		return response;
-	}
-
-}

package/src/runtime-pi/client/worker/Workport.js

@@ -1,86 +0,0 @@
-
-export default class Workport {
-
-    constructor() {
-        // --------
-        // Post messaging
-        // --------
-        this.messaging = {
-            post: (message, client = this.client) => {
-                if (!client) throw new Error(`No client for this operation.`);
-                client.postMessage(message);
-                return this.post;
-            },
-            listen: (callback, client = this.client) => {
-                (client || self).addEventListener('message', evt => {
-                    this.client = evt.source;
-                    const response = callback(evt);
-                    let responsePort = evt.ports[0];
-                    if (responsePort) {
-                        if (response instanceof Promise) {
-                            response.then(data => {
-                                responsePort.postMessage(data);
-                            });
-                        } else {
-                            responsePort.postMessage(response);
-                        }
-                    }
-                });
-                return this.post;
-            },
-            request: (message, client = this.client) => {
-                if (!client) throw new Error(`No client for this operation.`);
-                return new Promise(res => {
-                    let messageChannel = new MessageChannel();
-                    client.postMessage(message, [ messageChannel.port2 ]);
-                    messageChannel.port1.onmessage = e => res(e.data);
-                });
-            },
-            channel(channelId) {
-                if (!this.channels.has(channelId)) { this.channels.set(channelId, new BroadcastChannel(channel)); }
-                let channel = this.channels.get(channelId);
-                return {
-                    broadcast: message => channel.postMessage(message),
-                    listen: callback => channel.addEventListener('message', callback),
-                };
-            },
-            channels: new Map,
-        };
-
-        // --------
-        // Notifications
-        // --------
-        this.notifications = {
-            fire: (title, params = {}) => {
-                return new Promise((res, rej) => {
-                    if (!(self.Notification && self.Notification.permission === 'granted')) {
-                        return rej(self.Notification && self.Notification.permission);
-                    }
-                    notification.addEventListener('error', rej);
-                    let notification = new self.Notification(title, params);
-                    notification.addEventListener('click', res);
-                    notification.addEventListener('close', res);
-                });
-            },
-            handle: callback => {
-                self.addEventListener('notificationclick', callback);
-                return this.notifications;
-            },
-        };
-
-        // --------
-        // Push Notifications
-        // --------
-        this.push = {
-            listen: callback => {
-                self.addEventListener('push', callback);
-                return this.post;
-            },
-        };
-    }
-
-    setCurrentClient(client) {
-        this.client = client;
-    }
-
-}

package/src/runtime-pi/client/worker/index.js

@@ -1,21 +0,0 @@
-
-/**
- * @imports
- */
-import Context from './Context.js';
-import Application from './Application.js';
-import Runtime from './Runtime.js';
-
-/**
- * @start
- */
-export async function start(applicationInstance = null) {
-    const cx = this || {};
-    const defaultApplicationInstance = _cx => new Application(_cx);
-    return new Runtime(Context.create(cx), applicationInstance || defaultApplicationInstance);
-}
-
-/**
- * @APIS
- */
-export * as APIS from './Runtime.js';

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

@@ -1,116 +0,0 @@
-
-/**
- * imports
- */
-import Fs from 'fs';
-import Path from 'path';
-import QueryString from 'querystring';
-import Router from './Router.js';
-import _Application from '../Application.js';
-
-export default class Application extends _Application {
-
-    /**
-     * Application
-     * 
-     * @param Context cx
-     */
-    constructor(cx) {
-        super(cx);
-        this.renderFileCache = {};
-    }
-
-	// Returns router class
-	get Router() {
-		return Router;
-	}
-
-    /**
-     * Handles navigation events.
-     * 
-     * @param NavigationEvent       httpEvent
-     * @param Function              remoteFetch
-     * 
-     * @return Response
-     */
-    async handle(httpEvent, remoteFetch) {
-        // The app router
-        const router = new this.Router(this.cx, httpEvent.url.pathname);
-        const handle = async () => {
-            // --------
-            // ROUTE FOR DATA
-            // --------
-            let response = await router.route([httpEvent.request.method, 'default'], httpEvent, {}, async event => {
-                return router.file(event);
-            }, remoteFetch);
-            if (!(response instanceof httpEvent.Response)) {
-                response = httpEvent.Response.compat(response);
-            }
-            // --------
-            // Rendering
-            // --------
-            if (response.ok && response.meta.type === 'json' && typeof response.meta.body === 'object' && response.meta.body && httpEvent.request.headers.accept.match('text/html')) {
-                let rendering = await this.render(httpEvent, router, response);
-                if (typeof rendering !== 'string' && !(typeof rendering === 'object' && rendering && typeof rendering.toString === 'function')) {
-                    throw new Error('render() must return a string response or an object that implements toString()..');
-                }
-                rendering = rendering.toString();
-                response = new httpEvent.Response(rendering, {
-                    headers: { ...response.headers.json(), contentType: 'text/html', contentLength: (new Blob([rendering]).size) },
-                    status: response.status,
-                });
-            }
-
-            return response;
-        };
-        // --------
-        // PIPE THROUGH MIDDLEWARES
-        // --------
-        return (this.cx.middlewares || []).concat(handle).reverse().reduce((next, fn) => {
-            return () => fn.call(this.cx, httpEvent, router, next);
-        }, null)();
-    }
-
-    // Renderer
-    async render(httpEvent, router, response) {
-        let data = await response.jsonfy();
-        let rendering = await router.route('render', httpEvent, data, async (httpEvent, data) => {
-            var renderFile, pathnameSplit = httpEvent.url.pathname.split('/');
-            while ((renderFile = Path.join(this.cx.CWD, this.cx.layout.PUBLIC_DIR, './' + pathnameSplit.join('/'), 'index.html')) 
-            && (this.renderFileCache[renderFile] === false/* false on previous runs */ || !Fs.existsSync(renderFile))) {
-                this.renderFileCache[renderFile] = false;
-                pathnameSplit.pop();
-            }
-            const instanceParams = QueryString.stringify({
-                file: renderFile,
-                url: httpEvent.url.href,
-                root: this.cx.CWD,
-                oohtml_level: this.cx.server.oohtml_support,
-            });
-            const { window } = await import('@webqit/oohtml-ssr/instance.js?' + instanceParams);
-            // --------
-            // OOHTML would waiting for DOM-ready in order to be initialized
-            if (window.WebQit.DOM) {
-                await new Promise(res => window.WebQit.DOM.ready(res));
-            }
-            if (window.document.templates) {
-                await new Promise(res => (window.document.templatesReadyState === 'complete' && res(), window.document.addEventListener('templatesreadystatechange', res)));
-            }
-            if (window.document.state) {
-                if (!window.document.state.env) {
-                    window.document.setState({
-                        env: 'server',
-                    }, { update: true });
-                }
-                window.document.setState({ data, url: httpEvent.url }, { update: 'merge' });
-            }
-            if (window.document.templates) {
-                window.document.body.setAttribute('template', 'routes/' + httpEvent.url.pathname.split('/').filter(a => a).map(a => a + '+-').join('/'));
-            }
-            await new Promise(res => setTimeout(res, 60));
-            return window;
-        });
-        return rendering + '';
-    }
-
-}

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

@@ -1,16 +0,0 @@
-
-/**
- * @imports
- */
-import _Contex from '../../Context.js';
-
-export default class Context extends _Contex {
-    // env
-    get env() {
-        return this.dict.env || {};
-    }
-
-    set env(value) {
-        this.dict.env = value;
-    }
-}

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

@@ -1,159 +0,0 @@
-
-/**
- * @imports
- */
-import Fs from 'fs';
-import Url from 'url';
-import Path from 'path';
-import Mime from 'mime-types';
-import _Router from '../Router.js';
-
-/**
- * ---------------------------
- * The Router class
- * ---------------------------
- */
-			
-export default class Router extends _Router {
-
-    async readTick(thisTick) {
-        thisTick = { ...thisTick };
-        if (thisTick.trail) {
-            thisTick.currentSegment = thisTick.destination[thisTick.trail.length];
-            thisTick.currentSegmentOnFile = [ thisTick.currentSegment, '-' ].reduce((_segmentOnFile, _seg) => {
-                if (_segmentOnFile.index) return _segmentOnFile;
-                var _currentPath = thisTick.trailOnFile.concat(_seg).join('/'),
-                    routeHandlerFile;
-                return Fs.existsSync(routeHandlerFile = Path.join(this.cx.CWD, this.cx.layout.SERVER_DIR, _currentPath, 'index.js')) ? { seg: _seg, index: routeHandlerFile } : (
-                    Fs.existsSync(Path.join(this.cx.CWD, this.cx.layout.SERVER_DIR, _currentPath)) ? { seg: _seg, dirExists: true } : _segmentOnFile
-                );
-            }, { seg: null });
-            thisTick.trail = thisTick.trail.concat(thisTick.currentSegment);
-            thisTick.trailOnFile = thisTick.trailOnFile.concat(thisTick.currentSegmentOnFile.seg);
-            thisTick.exports = thisTick.currentSegmentOnFile.index ? await import(Url.pathToFileURL(thisTick.currentSegmentOnFile.index)) : undefined;
-        } else {
-            thisTick.trail = [];
-            thisTick.trailOnFile = [];
-            thisTick.currentSegmentOnFile = { index: Path.join(this.cx.CWD, this.cx.layout.SERVER_DIR, 'index.js') };
-            thisTick.exports = Fs.existsSync(thisTick.currentSegmentOnFile.index) 
-                ? await import(Url.pathToFileURL(thisTick.currentSegmentOnFile.index)) 
-                : null;
-        }
-        return thisTick;
-    }
-
-    finalizeHandlerContext(context, thisTick) {
-        if (thisTick.currentSegmentOnFile.index) {
-            context.dirname = Path.dirname(thisTick.currentSegmentOnFile.index);
-        }
-    }
-
-    pathJoin(...args) {
-        return Path.join(...args);
-    }
-
-    /**
-     * Reads a static file from the public directory.
-     * 
-     * @param ServerNavigationEvent httpEvent
-     * 
-     * @return Promise
-     */
-    file(httpEvent) {
-        let filename = Path.join(this.cx.CWD, this.cx.layout.PUBLIC_DIR, decodeURIComponent(httpEvent.url.pathname));
-        let index, ext = Path.parse(httpEvent.url.pathname).ext;
-        // if is a directory search for index file matching the extention
-        if (!ext && Fs.existsSync(filename) && Fs.lstatSync(filename).isDirectory()) {
-            ext = '.html';
-            index = `index${ext}`;
-            filename = Path.join(filename, index);
-        }
-        let enc, acceptEncs = [], supportedEncs = { gzip: '.gz', br: '.br' };
-        // based on the URL path, extract the file extention. e.g. .js, .doc, ...
-        // and process encoding
-        if ((acceptEncs = (httpEvent.request.headers.get('Accept-Encoding') || '').split(',').map(e => e.trim())).length
-        && (enc = acceptEncs.reduce((prev, _enc) => prev || (Fs.existsSync(filename + supportedEncs[_enc]) && _enc), null))) {
-            filename = filename + supportedEncs[enc];
-        } else {
-            if (!Fs.existsSync(filename)) return;
-            if (Object.values(supportedEncs).includes(ext)) {
-                enc = Object.keys(supportedEncs).reduce((prev, _enc) => prev || (supportedEncs[_enc] === ext && _enc), null);
-                ext = Path.parse(filename.substring(0, filename.length - ext.length)).ext;
-            }
-        }
-
-        // read file from file system
-        return new Promise(resolve => {
-            Fs.readFile(filename, function(err, data) {
-                let response;
-                if (err) {
-                    response = new httpEvent.Response(null, { status: 500, statusText: `Error reading static file: ${filename}` } );
-                } else {
-                    // if the file is found, set Content-type and send data
-                    let mime = Mime.lookup(ext);
-                    response = new httpEvent.Response(data, { headers: {
-                        contentType: mime === 'application/javascript' ? 'text/javascript' : mime,
-                        contentLength: Buffer.byteLength(data),
-                    } });
-                    if (enc) {
-                        response.headers.set('Content-Encoding', enc);
-                    }
-                }
-                response.attrs.filename = filename;
-                response.attrs.static = true;
-                response.attrs.index = index;
-                resolve(response);
-            });
-        });
-    }
-
-    /**
-     * Writes a file to the public directory.
-     * 
-     * @param object filename
-     * @param string content
-     * 
-     * @return bool
-     */
-    putPreRendered(filename, content) {
-        var _filename = Path.join(this.cx.layout.PUBLIC_DIR, '.', filename);
-        if (!Path.parse(filename).ext && filename.lastIndexOf('.') < filename.lastIndexOf('/')) {
-            _filename = Path.join(_filename, '/index.html');
-        }
-        var dir = Path.dirname(_filename);
-        if (!Fs.existsSync(dir)) {
-            Fs.mkdirSync(dir, {recursive:true});
-        }
-        return Fs.writeFileSync(_filename, content);
-    }
-
-    /**
-     * Deletes a file from the public directory.
-     * 
-     * @param object filename
-     * 
-     * @return bool
-     */
-    deletePreRendered(filename) {
-        return Fs.unlinkSync(filename);
-    }
-};
-
-// maps file extention to MIME typere
-const mimeTypes = {
-    '.ico':     'image/x-icon',
-    '.html':    'text/html',
-    '.js':      'text/javascript',
-    '.json':    'application/json',
-    '.css':     'text/css',
-    '.png':     'image/png',
-    '.jpeg':     'image/jpeg',
-    '.jpg':     'image/jpeg',
-    '.wav':     'audio/wav',
-    '.mp3':     'audio/mpeg',
-    '.svg':     'image/svg+xml',
-    '.pdf':     'application/pdf',
-    '.doc':     'application/msword'
-};
-
-export { mimeTypes };