@webqit/webflo 0.20.26 → 0.20.28

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "0.20.26",
+  "version": "0.20.28",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,9 +33,6 @@
     "site:build": "vitepress build site",
     "site:preview": "vitepress preview site --port 4173"
   },
-  "exports": {
-    "./apis": "./src/runtime-pi/apis.js"
-  },
   "bin": {
     "webflo": "src/webflo-cli.js",
     "webflo-certbot-http-auth-hook": "src/services-pi/cert/http-auth-hook.js",
@@ -44,13 +41,19 @@
   "dependencies": {
     "@octokit/webhooks": "^7.15.1",
     "@webqit/backpack": "^0.1.12",
+    "@webqit/fetch-plus": "^0.1.21",
+    "@webqit/keyval": "^0.2.17",
+    "@webqit/observer": "^3.8.14",
     "@webqit/oohtml-ssr": "^2.2.2",
-    "@webqit/use-live": "^0.5.44",
+    "@webqit/port-plus": "^0.1.19",
+    "@webqit/url-plus": "^0.1.4",
+    "@webqit/use-live": "^0.5.49",
     "@webqit/util": "^0.8.11",
     "chokidar": "^4.0.3",
     "dotenv": "^16.4.7",
     "esbuild": "^0.14.38",
     "fast-glob": "^3.3.3",
+    "idb": "^8.0.3",
     "mime-types": "^2.1.33",
     "simple-git": "^2.20.1",
     "urlpattern-polyfill": "^4.0.3"

package/src/build-pi/index.js

@@ -7,12 +7,12 @@ import { gzipSync, brotliCompressSync } from 'zlib';
 import { _afterLast, _beforeLast } from '@webqit/util/str/index.js';
 import { _isObject, _isArray } from '@webqit/util/js/index.js';
 import { jsFile } from '@webqit/backpack/src/dotfile/index.js';
+import { URLPatternPlus } from '@webqit/url-plus';
 import { bootstrap as serverBootstrap } from '../runtime-pi/webflo-server/bootstrap.js';
 import { bootstrap as clientBootstrap } from '../runtime-pi/webflo-client/bootstrap.js';
 import { bootstrap as workerBootstrap } from '../runtime-pi/webflo-worker/bootstrap.js';
 import { UseLiveTransform } from './esbuild-plugin-uselive-transform.js';
 import { CLIContext } from '../CLIContext.js';
-import '../runtime-pi/webflo-url/urlpattern.js';
 
 function declareConfig({ $source, configExport, indentation = 0 }) {
     const varName = 'config';
@@ -370,11 +370,13 @@ async function generateWorkerScript({ $context, bootstrap, ...restParams }) {
     for (const strategy of ['cache_first_urls', 'cache_only_urls']) {
         if (configExport.WORKER[strategy].length) {
             const [urls, patterns] = configExport.WORKER[strategy].reduce(([urls, patterns], url) => {
-                const patternInstance = new URLPattern(url, 'http://localhost');
+                const patternInstance = new URLPatternPlus(url, 'http://localhost');
                 const isPattern = patternInstance.isPattern();
-                if (isPattern && (patternInstance.pattern.hostname !== 'localhost' || patternInstance.pattern.port)) {
+                
+                if (isPattern && (patternInstance.hostname !== 'localhost' || patternInstance.port)) {
                     throw new Error(`Pattern URLs must have no origin part. Recieved "${url}".`);
                 }
+
                 return isPattern ? [urls, patterns.concat(patternInstance)] : [urls.concat(url), patterns];
             }, [[], []]);
             if (patterns.length) {
@@ -391,7 +393,7 @@ async function generateWorkerScript({ $context, bootstrap, ...restParams }) {
                 configExport.WORKER[strategy] = patterns.reduce((all, pattern) => {
                     const matchedFiles = files.filter((file) => pattern.test(file, 'http://localhost'));
                     if (matchedFiles.length) return all.concat(matchedFiles);
-                    throw new Error(`The pattern "${pattern.pattern.pathname}" didn't match any files.`);
+                    throw new Error(`The pattern "${pattern.pathname}" didn't match any files.`);
                 }, urls);
             }
         }

package/src/init-pi/index.js

@@ -5,7 +5,6 @@ import { exec } from 'child_process';
 import { _toTitle } from '@webqit/util/str/index.js';
 import { readInitConfig } from '../deployment-pi/util.js';
 import { CLIContext } from '../CLIContext.js';
-import * as deployment from '../deployment-pi/index.js';
 
 export const desc = {
     init: 'Generate a preset Webflo starter app.',

package/src/runtime-pi/{WebfloRuntime.js → AppRuntime.js}

@@ -1,33 +1,18 @@
-import { WebfloRouter } from './webflo-routing/WebfloRouter.js';
-import { response as responseShim, headers as headersShim } from './webflo-fetch/index.js';
-import { LiveResponse } from './webflo-fetch/LiveResponse.js';
+import { LiveResponse, ResponsePlus } from '@webqit/fetch-plus';
+import { WebfloRouter111 } from './webflo-routing/WebfloRouter111.js';
 import { AppBootstrap } from './AppBootstrap.js';
-import { HttpEvent } from './webflo-routing/HttpEvent.js';
-import { HttpThread } from './webflo-routing/HttpThread.js';
-import { HttpSession } from './webflo-routing/HttpSession.js';
-import { HttpUser } from './webflo-routing/HttpUser.js';
-import { _wq } from '../util.js';
+import { _meta } from '../util.js';
 
-export class WebfloRuntime {
+export class AppRuntime {
 
     #instanceController = new AbortController;
     get $instanceController() { return this.#instanceController; }
 
-    static get Router() { return WebfloRouter; }
-
-    static get HttpEvent() { return HttpEvent; }
-
-    static get HttpThread() { return HttpThread; }
-
-    static get HttpSession() { return HttpSession; }
-
-    static get HttpUser() { return HttpUser; }
-
     static create(bootstrap) { return new this(bootstrap); }
 
     #bootstrap;
-
     get bootstrap() { return this.#bootstrap; }
+
     get cx() { return this.bootstrap.cx; }
     get config() { return this.bootstrap.config; }
     get routes() { return this.bootstrap.routes; }
@@ -47,20 +32,6 @@ export class WebfloRuntime {
         if (this.bootstrap.init.SETUP) {
             await this.bootstrap.init.SETUP(this);
         }
-        await this.initCreateStorage();
-        return this.#instanceController;
-    }
-
-    async initCreateStorage() {
-        if (!this.bootstrap.init.createStorage) {
-            const inmemSessionRegistry = new Map;
-            this.bootstrap.init.createStorage = (namespace) => {
-                if (!inmemSessionRegistry.has(namespace)) {
-                    inmemSessionRegistry.set(namespace, new Map);
-                }
-                return inmemSessionRegistry.get(namespace);
-            };
-        }
         return this.#instanceController;
     }
 
@@ -76,48 +47,26 @@ export class WebfloRuntime {
         return this.#instanceController;
     }
 
-    createStorage(namespace, ttl) {
-        return this.bootstrap.init.createStorage(namespace, ttl);
-    }
-
     createRequest(href, init = {}) {
         return new Request(href, init);
     }
 
-    createHttpThread({ store, threadID, ...rest }) {
-        return this.constructor.HttpThread.create({ store, threadID, ...rest });
-    }
-
-    createHttpCookies({ request, thread, ...rest }) {
-        return this.constructor.HttpCookies.create({ request, thread, ...rest });
-    }
-
-    createHttpSession({ store, request, thread, ...rest }) {
-        return this.constructor.HttpSession.create({ store, request, thread, ...rest });
-    }
-
-    createHttpUser({ store, request, thread, client, ...rest }) {
-        return this.constructor.HttpUser.create({ store, request, thread, client, ...rest });
-    }
-
-    createHttpEvent({ request, thread, cookies, session, user, client, detail, signal, state, ...rest }) {
-        return this.constructor.HttpEvent.create(null, { request, thread, cookies, session, user, client, detail, signal, state, ...rest });
-    }
-
     async dispatchNavigationEvent({ httpEvent, crossLayerFetch, clientPortB }) {
         const { flags: FLAGS, logger: LOGGER } = this.cx;
 
         // Dispatch event
-        const router = new this.constructor.Router(this, httpEvent.url.pathname);
+        const router = new WebfloRouter111(this, httpEvent.url.pathname);
         await router.route(['SETUP'], httpEvent.spawn());
 
         // Do proper routing for respone
         const response = await new Promise(async (resolve) => {
             let autoLiveResponse, response;
-            httpEvent.client.wqLifecycle.messaging.then(() => {
+
+            httpEvent.client.readyStateChange('messaging').then(() => {
                 autoLiveResponse = new LiveResponse(null, { status: 202, statusText: 'Accepted', done: false });
                 resolve(autoLiveResponse);
             });
+
             const route = async () => {
                 const routeMethods = [httpEvent.request.method, 'default'];
                 const remoteFetch = (...args) => this.remoteFetch(...args);
@@ -134,53 +83,46 @@ export class WebfloRuntime {
                 response = new Response(null, { status: 500, statusText: e.message });
             }
 
-            if (!/Response/.test(LiveResponse.test(response))) {
-                const isLifecyleComplete = httpEvent.lifeCycleComplete() ?? true;
+            if (autoLiveResponse) {
+                await this.handleThreadStatus(httpEvent, response);
+                await autoLiveResponse.replaceWith(response, { done: true });
+                return;
+            }
+
+            if (response instanceof Response) {
+                ResponsePlus.upgradeInPlace(response);
+            } else if (!(response instanceof LiveResponse)) {
+                const isLifecyleComplete = ['waiting', 'done'].includes(httpEvent.readyState);
                 response = LiveResponse.test(response) !== 'Default' || !isLifecyleComplete
-                    ? await LiveResponse.from(response, { done: isLifecyleComplete })
-                    : responseShim.from.value(response);
+                    ? LiveResponse.from(response, { done: isLifecyleComplete })
+                    : ResponsePlus.from(response);
             }
 
             // Any "status" in thread?
             await this.handleThreadStatus(httpEvent, response);
-
-            // Resolve now...
-            if (autoLiveResponse) {
-                await autoLiveResponse.replaceWith(response, { done: true });
-            } else {
-                resolve(response);
-            }
+            resolve(response);
         });
 
-        // Commit data in the exact order. Reason: in how they depend on each other
-        for (const storage of [httpEvent.user, httpEvent.session, httpEvent.cookies]) {
-            await storage?.commit?.(response, FLAGS['dev']);
-        }
-
         // End-of-life cleanup
         const cleanup = async () => {
-            for (const storage of [httpEvent.user, httpEvent.session, httpEvent.cookies]) {
-                storage.cleanup();
-            }
-            if (!httpEvent.thread.extended) {
-                await httpEvent.thread.clear();
-            }
+            await Promise.all([httpEvent.thread, httpEvent.user, httpEvent.session, httpEvent.cookies].map((x) => x._cleanup()));
         };
 
-        // Wait for any whileLive promises to resolve
-        if (LiveResponse.test(response) === 'LiveResponse' && response.whileLive()) {
-            httpEvent.waitUntil(response.whileLive(true));
+        // Wait for any "live" response to resolve
+        if (response instanceof LiveResponse && response.readyState !== 'done') {
+            httpEvent.waitUntil(response.readyStateChange('done'));
+            httpEvent.waitUntil(httpEvent.client.readyStateChange('open').then(async () => {
+                await new Promise((r) => setTimeout(r, 100));
+            }));
         }
 
-        // Send the X-Background-Messaging-Port header
+        // Send the X-Message-Port header
         // This server's event lifecycle management
-        if (!(httpEvent.lifeCycleComplete() ?? true)) {
+        if (!['waiting', 'done'].includes(httpEvent.readyState)) {
             if (this.isClientSide) {
-                const responseMeta = _wq(response, 'meta');
-                responseMeta.set('background_port', clientPortB);
+                LiveResponse.attachPort(response, clientPortB);
             } else {
-                const upstreamBackgroundPort = response.headers.get('X-Background-Messaging-Port');
-                response.headers.set('X-Background-Messaging-Port', clientPortB);
+                response.headers.set('X-Message-Port', clientPortB);
             }
 
             // On navigation:
@@ -195,42 +137,44 @@ export class WebfloRuntime {
                     }
                 }, 0);
             });
+
             // On close:
             // Abort httpEvent itself
-            httpEvent.client.wqLifecycle.close.then(() => {
+            httpEvent.client.readyStateChange('close').then(() => {
                 httpEvent.abort();
             });
 
             // On ROOT event complete:
             // Close httpEvent.client
-            httpEvent.lifeCycleComplete(true).then(async () => {
+            httpEvent.readyStateChange('done').then(async () => {
                 httpEvent.client.close();
-                cleanup();
+                await cleanup();
             });
-        } else cleanup();
+        } else await cleanup();
 
-        if (!this.isClientSide && LiveResponse.test(response) === 'LiveResponse') {
+        if (!this.isClientSide
+            && response instanceof LiveResponse) {
             // Must convert to Response on the server-side before returning
-            return await response.toResponse({ client: httpEvent.client });
+            const outgoingResponse = response.toResponse({ port: httpEvent.client });
+            return outgoingResponse;
         }
 
         return response;
     }
 
     async handleThreadStatus(httpEvent, response) {
-        if (!response.headers.get('Location')) {
-            const status = await httpEvent.thread.consume('status', true);
-            if (!status.length) return;
-            // Fire redirect message?
-            httpEvent.waitUntil(new Promise((resolve) => {
-                httpEvent.client.wqLifecycle.open.then(async () => {
-                    setTimeout(() => {
-                        httpEvent.client.postMessage(status, { wqEventOptions: { type: 'alert' } });
-                        resolve();
-                    }, 500); // half a sec
-                }, { once: true });
-            }));
-        }
+        if ((response instanceof Response
+            || response instanceof LiveResponse)
+            && response.headers.get('Location')) return;
+
+        const status = await httpEvent.thread.consume('status', true);
+        if (!status.length) return;
+
+        httpEvent.waitUntil(httpEvent.client.readyStateChange('open').then(async () => {
+            await new Promise((r) => setTimeout(r, 100));
+            httpEvent.client.postMessage(status, { type: 'alert' });
+            await new Promise((r) => setTimeout(r, 100));
+        }));
     }
 
     streamSlice(stream, { start, end }) {
@@ -328,13 +272,13 @@ export class WebfloRuntime {
 
     createStreamingResponse(httpEvent, readStream, stats) {
         let response;
-        const requestRange = headersShim.get.value.call(httpEvent.request.headers, 'Range', true); // Parses the Range header
+        const requestRange = httpEvent.request.headers.get('Range', true); // Parses the Range header
         if (requestRange.length) {
             const streams = requestRange.reduce((streams, range) => {
                 if (!streams) return;
-                const [start, end] = range.render(stats.size); // Resolve offsets
+                const [start, end] = range.resolveAgainst(stats.size); // Resolve offsets
                 const currentStart = (streams[streams.length - 1]?.end || -1) + 1;
-                if (!range.isValid(currentStart, stats.size)) return; // Only after rendering()
+                if (!range.canResolveAgainst(currentStart, stats.size)) return; // Only after rendering()
                 return streams.concat({ start, end, stream: readStream({ start, end }) });
             }, []);
             if (!streams) {

package/src/runtime-pi/webflo-client/DeviceCapabilities.js

@@ -1,4 +1,4 @@
-import { Observer } from '@webqit/use-live';
+import { Observer } from '@webqit/observer';
 
 export class DeviceCapabilities {