@webqit/webflo 1.0.17 → 1.0.19

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/runtime-pi/HttpEvent.js

@@ -100,6 +100,50 @@ export class HttpEvent {
         return [301, 302, 303, 307, 308].includes(this.#response?.status);
     }
 
+    async stream(callback, { interval = 3000, maxClock = 30, crossNavigation = false } = {}) {
+        return new Promise((res) => {
+            const state = { connected: false, navigatedAway: false };
+            const start = () => {
+                const poll = async (maxClock) => {
+                    await new Promise(($res) => setTimeout($res, interval));
+                    if (maxClock === 0 || !state.connected || state.navigatedAway) {
+                        res(callback());
+                        return;
+                    }
+                    await callback(async (response, endOfStream = false) => {
+                        if (endOfStream) {
+                            res(response);
+                        } else {
+                            await this.client.postMessage(response, { messageType: 'response' });
+                        }
+                    });                    
+                    poll(typeof maxClock === 'number' && maxClock > 0 ? --maxClock : maxClock);
+                };
+                poll(maxClock);
+            };
+            // Life cycle management
+            this.client.on('connected', () => {
+                state.connected = true;
+                start();
+            });
+            this.client.on('empty', () => {
+                state.connected = false;
+            });
+            this.client.handleMessages('navigation', (e) => {
+                if (!crossNavigation
+                || (crossNavigation === -1 && e.data.pathname === this.url.pathname)
+                || (typeof crossNavigation === 'function' && !crossNavigation(e.data))) {
+                    state.navigatedAway = true;
+                }
+            });
+            setTimeout(() => {
+                if (!state.connected) {
+                    res();
+                }
+            }, 30000/*30sec*/);
+        });
+    }
+
     async with(url, init = {}) {
         if (!this.request) {
             return new HttpEvent(this, { ...this.#init, url });

package/src/runtime-pi/WebfloRouter.js

@@ -8,7 +8,7 @@ export class WebfloRouter {
         this.path = _isArray(path) ? path : (path + '').split('/').filter(a => a);
     }
 
-    async route(method, event, arg, _default, remoteFetch = null) {
+    async route(method, event, arg, _default, remoteFetch = null, requestLifecycle = null) {
 
         const $this = this;
         const $runtime = this.cx.runtime;
@@ -74,9 +74,10 @@ export class WebfloRouter {
                         _next.stepname = nextPathname[0];
                         // -------------
                         return new Promise(async (res) => {
-                            thisTick.event.onRespondWith = (response) => {
+                            thisTick.event.onRespondWith = async (response) => {
                                 thisTick.event.onRespondWith = null;
                                 res(response);
+                                await requestLifecycle.responsePromise;
                             };
                             const $returnValue = Promise.resolve(handler.call(thisContext, thisTick.event, thisTick.arg, _next/*next*/, remoteFetch));
                             // This should listen first before waitUntil's listener

package/src/runtime-pi/WebfloRuntime.js

@@ -3,24 +3,27 @@ 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 });
-        }
-    }
+        const requestLifecycle = {};
+        requestLifecycle.responsePromise = new Promise(async (res) => {
+            // 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), requestLifecycle);
+            };
+            try {
+                // Route for response
+                res(await (this.cx.middlewares || []).concat(route).reverse().reduce((next, fn) => {
+                    return () => fn.call(this.cx, httpEvent, router, next);
+                }, null)());
+            } catch (e) {
+                console.error(e);
+                res(new Response(null, { status: 500, statusText: e.message }));
+            }
+        });
+        return await requestLifecycle.responsePromise;
+   }
 
     async normalizeResponse(httpEvent, response, forceCommit = false) {
         // Normalize response

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

@@ -369,11 +369,11 @@ export class WebfloClient extends WebfloRuntime {
         scope.context = {};
         if (window.webqit?.oohtml?.configs) {
             const { BINDINGS_API: { api: bindingsConfig } = {}, } = window.webqit.oohtml.configs;
-            scope.context = this.host[bindingsConfig.bindings].data || {};
+            scope.context = this.host[bindingsConfig.bindings] || {};
         }
-        if (scope.request.method === 'GET') {
-            // Ping any existing background process
-            this.#backgroundMessaging.postMessage('navigation');
+        if (scope.request.method === 'GET' || (scope.request.method === 'POST' && scope.url.pathname !== this.location.pathname)) {
+            // Ping existing background process
+            this.#backgroundMessaging.postMessage({ ...Url.copy(scope.url), method: scope.request.method }, { messageType: 'navigation' });
         }
         // Dispatch for response
         scope.response = await this.dispatch(scope.httpEvent, scope.context, async (event) => {
@@ -385,7 +385,7 @@ export class WebfloClient extends WebfloRuntime {
         });
         // ---------------
         // Response processing
-        scope.hasBackgroundActivity = scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
+        scope.hasBackgroundActivity = scope.clientMessaging.isMessaging() || scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
         scope.response = await this.normalizeResponse(scope.httpEvent, scope.response);
         if (scope.response.headers.get('Location')) {
             if (scope.redirectMessage) {
@@ -436,7 +436,7 @@ export class WebfloClient extends WebfloRuntime {
         // Only render now
         if ([202/*Accepted*/, 304/*Not Modified*/].includes(scope.response.status)) {
             if (scope.backgroundMessaging) {
-                scope.backgroundMessaging.addEventListener('response', () => {
+                scope.backgroundMessaging.addEventListener('response', (e) => {
                     scope.resetStates();
                 });
                 return;

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

@@ -141,7 +141,6 @@ export class WebfloSubClient extends WebfloClient {
 		const top = (window.outerHeight - height) / 2;
 		const popup = window.open(location, '_blank', `popup=true,width=${width},height=${height},left=${left},top=${top}`);
 		if (backgroundMessaging) {
-			backgroundMessaging.postMessage('keepAlive');
 			Observer.set(this.navigator, 'redirecting', new Url/*NOT URL*/(location), { diff: true });
 			backgroundMessaging.addEventListener('close', (e) => {
 				Observer.set(this.navigator, 'redirecting', null);

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

@@ -183,7 +183,7 @@ export class WebfloWorker extends WebfloRuntime {
 		});
 		// ---------------
         // Response processing
-        scope.hasBackgroundActivity = scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
+        scope.hasBackgroundActivity = scope.clientMessaging.isMessaging() || scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
         scope.response = await this.normalizeResponse(scope.httpEvent, scope.response, scope.hasBackgroundActivity);
 		if (scope.hasBackgroundActivity) {
 			scope.response.headers.set('X-Background-Messaging', `ch:${scope.clientMessaging.port.name}`);

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

@@ -485,7 +485,9 @@ export class WebfloServer extends WebfloRuntime {
                 promise = Promise.resolve(promise);
                 scope.eventLifecyclePromises.add(promise);
                 scope.eventLifecyclePromises.dirty = true;
-                promise.then(() => scope.eventLifecyclePromises.delete(promise));
+                promise.then(() => {
+                    scope.eventLifecyclePromises.delete(promise);
+                });
             },
             respondWith: async (response, isRedirectMessage = false) => {
                 if (!isRedirectMessage && scope.eventLifecyclePromises.dirty && !scope.eventLifecyclePromises.size) {
@@ -533,7 +535,7 @@ export class WebfloServer extends WebfloRuntime {
         });
         // ---------------
         // Response processing
-        scope.hasBackgroundActivity = scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
+        scope.hasBackgroundActivity = scope.clientMessaging.isMessaging() || scope.eventLifecyclePromises.size || (scope.redirectMessage && !(scope.response instanceof Response && scope.response.headers.get('Location')));
         scope.response = await this.normalizeResponse(scope.httpEvent, scope.response, scope.hasBackgroundActivity);
         if (scope.hasBackgroundActivity) {
             scope.response.headers.set('X-Background-Messaging', `ws:${scope.clientMessaging.portID}`);
@@ -562,7 +564,9 @@ export class WebfloServer extends WebfloRuntime {
                         scope.clientMessaging.close();
                     }, 100);
                 });
-            } else scope.clientMessaging.close();
+            } else {
+                scope.clientMessaging.close();
+            }
         });
         return scope.response;
     }