@webqit/webflo 0.20.26 → 0.20.27

package/src/runtime-pi/webflo-routing/HttpState.js

@@ -1,182 +0,0 @@
-import { _isObject } from '@webqit/util/js/index.js';
-import { _even } from '@webqit/util/obj/index.js';
-import { HttpEvent } from './HttpEvent.js';
-
-export class HttpState {
-
-    #store;
-    #request;
-    #thread;
-    #modified = false;
-
-    constructor({ store, request, thread }) {
-        this.#store = store || new Map;
-        this.#request = request;
-        this.#thread = thread === true ? this : thread;
-    }
-
-    async has(key) { return await this.#store.has(key); }
-
-    async get(key) { return await this.#store.get(key); }
-
-    async set(key, value) {
-        await this.#store.set(key, value);
-        this.#modified = true;
-        await this.emit(key, value);
-        return this;
-    }
-
-    async delete(key) {
-        await this.#store.delete(key);
-        this.#modified = true;
-        await this.emit(key);
-        return this;
-    }
-
-    async clear() {
-        await this.#store.clear();
-        this.#modified = true;
-        await this.emit();
-        return this;
-    }
-
-    async keys() { return [...await this.#store.keys()]; }
-
-    async values() { return [...await this.#store.values()]; }
-
-    async entries() { return [...await this.#store.entries()]; }
-
-    async json(arg = null) {
-        if (!arguments.length || typeof arg === 'boolean') {
-            return Object.fromEntries(await this.#store.entries());
-        }
-        if (!_isObject(arg)) {
-            throw new Error(`Argument must be a valid JSON object`);
-        }
-        return await Promise.all(Object.entries(arg).map(([key, value]) => {
-            return this.set(key, value);
-        }));
-    }
-
-    async forEach(callback) { (await this.entries()).forEach(([key, value], i) => callback(value, key, i)); }
-
-    [Symbol.iterator]() { return this.entries().then((entries) => entries[Symbol.iterator]()); }
-
-    get size() { return this.#store.sizs; }
-
-    async commit() {
-        this.#modified = false;
-    }
-
-    #listeners = new Set;
-    async emit(attr, value) {
-        const returnValues = [];
-        for (const subscription of this.#listeners) {
-            const { attr: $attr, handler, options } = subscription;
-            if (arguments.length && $attr !== attr) continue;
-            if (arguments.length > 1) {
-                returnValues.push(handler(value));
-            } else {
-                returnValues.push(handler());
-            }
-            if (options.once) this.#listeners.delete(subscription);
-        }
-        await Promise.all(returnValues);
-    }
-
-    observe(attr, handler, options = {}) {
-        if (typeof this.#store.observe === 'function') {
-            return this.#store.observe(attr, handler, options);
-        }
-        const subscription = { attr, handler, options };
-        this.#listeners.add(subscription);
-        if (options.signal) {
-            options.signal.addEventListener('abort', () => {
-                this.#listeners.delete(subscription);
-            });
-        }
-        return () => {
-            this.#listeners.delete(subscription);
-        }
-    }
-
-    cleanup() {
-        if (typeof this.#store.cleanup === 'function') {
-            this.#store.cleanup();
-        }
-        this.#listeners.clear();
-    }
-
-    #handlers = new Map;
-    defineHandler(attr, ...handlers) {
-        const $handlers = [];
-        for (let handler of handlers) {
-            if (typeof handler === 'function') {
-                handler = { callback: handler };
-            } else if (typeof handler === 'string') {
-                handler = { url: handler };
-            } else if (!(_isObject(handler) && (handler = { ...handler })) 
-                || 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)`);
-            }
-            if (_isObject(handler.with)) {
-                handler.with = { ...handler.with };
-            } else if (handler.with) {
-                throw new Error(`The "with" parameter must be a valid JSON object`);
-            }
-            $handlers.push(handler);
-        }
-        this.#handlers.set(attr, $handlers);
-    }
-
-    getHandlers() { return this.#handlers; }
-
-    async require(attrs, callback = null, noNulls = false) {
-        const entries = [];
-        main: for await (const attr of [].concat(attrs)) {
-            if (!(await this.has(attr)) || (noNulls && [undefined, null].includes(await 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;
-                    }
-                    if (callback instanceof HttpEvent) {
-                        await callback.redirectWith(handler.url, handler.with || {});
-                        return new Promise(() => { });
-                    }
-                    const urlRewrite = new URL(handler.url, this.#request.url);
-                    const newThread = this.#thread.spawn(urlRewrite.searchParams.get('_thread')/* show */);
-                    urlRewrite.searchParams.set('_thread', newThread.threadID);
-                    await newThread.append('back', this.#request.url.replace(urlRewrite.origin, ''));
-                    if (handler.with) {
-                        for (const [key, value] of Object.entries(handler.with)) {
-                            await newThread.append(key, value);
-                        }
-                    }
-                    return new Response(null, {
-                        status: 302, headers: {
-                            Location: urlRewrite
-                        }
-                    });
-                }
-            }
-            entries.push(await this.get(attr));
-        }
-        if (callback && !(callback instanceof HttpEvent)) {
-            return await callback(...entries);
-        }
-        return entries;
-    }
-}

package/src/runtime-pi/webflo-server/ServerSideCookies.js

@@ -1,22 +0,0 @@
-import { headers as headersShim } from '../webflo-fetch/index.js';
-import { HttpCookies } from '../webflo-routing/HttpCookies.js';
-
-export class ServerSideCookies extends HttpCookies {
-    static create({ request, thread }) {
-        const cookies = headersShim.get.value.call(request.headers, 'Cookie', true);
-        return new this({
-            request,
-            thread,
-            entries: cookies.map((c) => [c.name, c])
-        });
-    }
-
-    async commit(response = null) {
-        if (response) {
-            for (const cookieStr of await this.render()) {
-                response.headers.append('Set-Cookie', cookieStr);
-            }
-        }
-        await super.commit();
-    }
-}

package/src/runtime-pi/webflo-server/ServerSideSession.js

@@ -1,40 +0,0 @@
-import { HttpSession } from '../webflo-routing/HttpSession.js';
-import { headers as headersShim } from '../webflo-fetch/index.js';
-
-export class ServerSideSession extends HttpSession {
-
-    static create({ store, request, thread, sessionID, ttl }) {
-        return new this({
-            store,
-            request,
-            thread,
-            sessionID,
-            ttl
-        });
-    }
-
-    #sessionID;
-    get sessionID() { return this.#sessionID; }
-    #ttl;
-    
-    constructor({ store, request, thread, sessionID, ttl }) {
-        if (!sessionID) {
-            throw new Error(`sessionID is required`);
-        }
-        super({
-            store,
-            request,
-            thread,
-        });
-        this.#sessionID = sessionID;
-        this.#ttl = ttl;
-    }
-
-    async commit(response = null, devMode = false) {
-        if (response && !headersShim.get.value.call(response.headers, 'Set-Cookie', true).find((c) => c.name === '__sessid')) {
-            // expires six months
-            response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; ${!devMode ? 'Secure; ' : ''}HttpOnly; SameSite=Lax${this.#ttl ? `; Max-Age=${this.#ttl}` : ''}`);
-        }
-        await super.commit();
-    }
-}

package/src/runtime-pi/webflo-server/messaging/Client.js

@@ -1,27 +0,0 @@
-import { WQStarPort } from '../../webflo-messaging/WQStarPort.js';
-import { ClientRequestRealtime } from './ClientRequestRealtime.js';
-
-export class Client extends WQStarPort {
-
-    #clientID;
-    get clientID() { return this.#clientID; }
-
-    constructor(clientID) {
-        super();
-        this.#clientID = clientID;
-    }
-
-    getRequestRealtime(portID) {
-        return this.findPort((port) => port.portID === portID);
-    }
-
-    createRequestRealtime(portID, url = null) {
-        const requestPort = new ClientRequestRealtime(portID, url);
-        this.addPort(requestPort);
-        setTimeout(() => {
-            if (requestPort.length || !this.findPort((port) => port === requestPort)) return;
-            requestPort.close(true);
-        }, 15000/*15sec*/);
-        return requestPort;
-    }
-}

package/src/runtime-pi/webflo-server/messaging/Clients.js

@@ -1,25 +0,0 @@
-import { WQStarPort } from '../../webflo-messaging/WQStarPort.js';
-import { WQRelayPort } from '../../webflo-messaging/WQRelayPort.js';
-import { Client } from './Client.js';
-
-export class Clients extends WQStarPort {
-    #channels = new Map;
-
-    getClient(clientID, autoCreate = false) {
-        if (autoCreate && !this.findPort((client) => client.clientID === clientID)) {
-            const client = new Client(clientID);
-            const cleanup = this.addPort(client);
-            client.wqLifecycle.close.then(cleanup);
-        }
-        return this.findPort((client) => client.clientID === clientID);
-    }
-
-    getChannel(channelName, autoCreate = false) {
-        if (!this.#channels.has(channelName) && autoCreate) {
-            const channel = new WQRelayPort(channelName);
-            this.#channels.set(channelName, channel);
-            channel.wqLifecycle.close.then(() => this.#channels.delete(channelName));
-        }
-        return this.#channels.get(channelName);
-    }
-}

package/src/runtime-pi/webflo-url/Url.js

@@ -1,156 +0,0 @@
-import { _with } from '@webqit/util/obj/index.js';
-import { _isArray, _isObject, _isTypeObject, _isString, _isEmpty } from '@webqit/util/js/index.js';
-import { DeepURLSearchParams } from './util.js';
-import { Observer } from '@webqit/use-live';
-
-export class Url {
-
-	constructor(input) {
-        const Self = this.constructor;
-		// -----------------------
-		// Helpers
-		var _strictEven = (a, b) => {
-			if (_isObject(a) && _isObject(b)) {
-				return _strictEven(Object.keys(a), Object.keys(b)) 
-				&& _strictEven(Object.values(a), Object.values(b));
-			}
-			if (_isArray(a) && _isArray(b)) {
-				return a.length === b.length 
-				&& a.reduce((recieved, item, i) => recieved && item === b[i], true);
-			}
-			return a === b;
-		};
-		Observer.intercept(this, 'set', (e, prev, next) => {
-			if (e.key === 'hash' && e.value && !e.value.startsWith('#')) {
-				e.value = '#' + e.value;
-			} else if (e.key === 'search' && e.value && !e.value.startsWith('?')) {
-				e.value = '?' + e.value;
-			}
-			return next();
-		});
-		// -----------------------
-		// When any one of these properties change,
-		// the others are automatically derived
-		Observer.observe(this, changes => {
-			var urlObj = {};
-			var onlyHrefChanged;
-			for (var e of changes) {
-				// ----------
-				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;
-				}
-				// ----------
-				if (e.key === 'query' && !e.related.includes('search')) {
-					// "query" was updated. So we update "search"
-					var search = Self.toSearch(this.query); // Not e.value, as that might be a subtree value
-					if (search !== this.search) {
-						urlObj.search = 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,
-					usernamePassword = [ this.username, this.password ].filter(a => a);
-				if (usernamePassword.length === 2) {
-					fullOrigin = `${this.protocol}//${usernamePassword.join(':')}@${this.hostname}${(this.port ? `:${this.port}` : '')}`;
-				}
-				var href = [ fullOrigin, urlObj.pathname || this.pathname, urlObj.search || this.search || (this.href.includes('?') ? '?' : ''), this.hash || (this.href.includes('#') ? '#' : '') ].join('');
-				if (href !== this.href) {
-					urlObj.href = href;
-				}
-			}
-			if (!_isEmpty(urlObj)) {
-				return Observer.set(this, urlObj);
-			}
-		}, { diff: true });
-		// -----------------------
-		// Validate e.detail
-		Observer.observe(this, changes => {
-			changes.forEach(e => {
-				if (e && e.detail) {
-					if (!_isTypeObject(e.detail)) {
-						throw new Error('"e.detail" can only be of type object.');
-					}
-					if (e.detail.request && !_isObject(e.detail.request)) {
-						throw new Error('"e.detail.request" can only be of type object.');
-					}
-				}
-			});
-		}, { diff: true });
-		// -----------------------
-		// Startup properties
-        Observer.set(this, _isString(input) ? Self.parseUrl(input) : Url.copy(input));
-	}
-
-	toString() {
-        return this.href;
-    }
-    
-	static from(href) {
-        return new this(_isObject(href) ? href : this.parseUrl(href));
-	}
-
-	static copy(urlObj) {
-		var url = urlProperties.reduce((obj, prop) => _with(obj, prop, urlObj[prop] || ''), {});
-		if (!('query' in urlObj)) {
-			delete url.query;
-		}
-		return url;
-	}
-
-	static parseUrl(href) {
-		var a = new URL(href);
-		return this.copy(a);
-	}
-
-	static toQuery(search) {
-		return DeepURLSearchParams.eval({}, search);
-	}
-
-	static toSearch(query) {
-		var search = DeepURLSearchParams.stringify(query);
-		return search ? '?' + search : '';
-	}
-}
-
-const urlProperties = [
-	'protocol', 
-	'username',
-	'password',
-	'host',
-	'hostname',
-	'port',
-	'origin',
-	'pathname',
-	'search',
-	'query',
-	'hash',
-	'href',
-];

package/src/runtime-pi/webflo-url/index.js

@@ -1 +0,0 @@
-import './urlpattern.js';

package/src/runtime-pi/webflo-url/urlpattern.js

@@ -1,38 +0,0 @@
-import { _isNumeric } from '@webqit/util/js/index.js';
-if (typeof URLPattern === 'undefined') {
-    await import('urlpattern-polyfill');
-}
-
-const { exec: execMethod } = URLPattern.prototype;
-const urlPatternMethods = {
-    isPattern: {
-        value: function () {
-            return Object.keys(this.keys || {}).some((compName) => this.keys[compName].length);
-        }
-    },
-    exec: {
-        value: function (...args) {
-            let components = execMethod.call(this, ...args);
-            if (!components) return;
-            components.vars = Object.keys(this.keys).reduce(({ named, unnamed }, compName) => {
-                this.keys[compName].forEach(key => {
-                    let value = components[compName].groups[key.name];
-                    if (typeof key.name === 'number') {
-                        unnamed.push(value);
-                    } else {
-                        named[key.name] = value;
-                    }
-                });
-                return { named, unnamed };
-            }, { named: {}, unnamed: [] });
-            components.render = (str) => {
-                return str.replace(/\$(\$|[0-9A-Z]+)/gi, (a, b) => {
-                    return b === '$' ? '$' : (_isNumeric(b) ? components.vars.unnamed[b - 1] : components.vars.named[b]) || '';
-                });
-            }
-            return components;
-        }
-    },
-};
-
-Object.defineProperties(URLPattern.prototype, urlPatternMethods);

package/src/runtime-pi/webflo-url/util.js

@@ -1,109 +0,0 @@
-import { _isString, _isNumeric, _isArray, _isTypeObject } from '@webqit/util/js/index.js';
-
-export const DeepURLSearchParams = {
-    // Parse a search params string into an object
-    eval(targetObject, str, delim = '&') {
-        str = str || '';
-        (str.startsWith('?') ? str.substr(1) : str)
-            .split(delim).filter(q => q).map(q => q.split('=').map(q => q.trim()))
-            .forEach(q => this.set(targetObject, q[0], decodeURIComponent(q[1])));
-        return targetObject;
-    },
-    // Stringify an object into a search params string
-    stringify(targetObject, delim = '&') {
-        const q = [];
-        Object.keys(targetObject).forEach(key => {
-            this.reduceValue(targetObject[key], key, (_value, _pathNotation, suggestedKeys = undefined) => {
-                if (suggestedKeys) return suggestedKeys;
-                q.push(`${_pathNotation}=${encodeURIComponent(_value)}`);
-            });
-        });
-        return q.join(delim);
-    },
-    // Get value by path notation
-    get(targetObject, pathNotation) {
-        return this.reducePath(pathNotation, targetObject, (key, _targetObject) => {
-            if (!_targetObject && _targetObject !== 0) return;
-            return _targetObject[key];
-        });
-    },
-    // Set value by path notation
-    set(targetObject, pathNotation, value) {
-        this.reducePath(pathNotation, targetObject, function(_key, _targetObject, suggestedBranch = undefined) {
-            let _value = value;
-            if (suggestedBranch) { _value = suggestedBranch; }
-            if (_key === '' && _isArray(_targetObject)) {
-                _targetObject.push(_value);
-            } else {
-                _targetObject[_key] = _value;
-            }
-            return _value;
-        });
-    },
-    
-    // Resolve a value to its leaf nodes
-    reduceValue(value, contextPath, callback) {
-        if (_isTypeObject(value)) {
-            let suggestedKeys = Object.keys(value);
-            let keys = callback(value, contextPath, suggestedKeys);
-            if (_isArray(keys)) {
-                return keys.forEach(key => {
-                    this.reduceValue(value[key], contextPath ? `${contextPath}[${key}]` : key, callback);
-                });
-            }
-        }
-        callback(value, contextPath);
-    },
-    // Resolve a path to its leaf index
-    reducePath(pathNotation, contextObject, callback) {
-        if (_isString(pathNotation) && pathNotation.endsWith(']') && _isTypeObject(contextObject)) {
-            let [ key, ...rest ] = pathNotation.split('[');
-            if (_isNumeric(key)) { key = parseInt(key); }
-            rest = rest.join('[').replace(']', '');
-            let branch;
-            if (key in contextObject) {
-                branch = contextObject[key];
-            } else {
-                let suggestedBranch = rest === '' || _isNumeric(rest.split('[')[0]) ? [] : {};
-                branch = callback(key, contextObject, suggestedBranch);
-            }
-            return this.reducePath(rest, branch, callback);
-        }
-        if (_isNumeric(pathNotation)) { pathNotation = parseInt(pathNotation); }
-        return callback(pathNotation, contextObject);
-    },    
-};
-
-export const path = {
-    join(/* path segments */) {
-        // Split the inputs into a list of path commands.
-        let parts = [], backsteps = 0;
-        for ( let i = 0, l = arguments.length; i < l; i++ ) {
-            parts = parts.concat( arguments[ i ].split( '/' ) );
-        }
-        // Interpret the path commands to get the new resolved path.
-        let newParts = [];
-        for ( let i = 0, l = parts.length; i < l; i++ ) {
-            let part = parts[ i ];
-            // Remove leading and trailing slashes
-            // Also remove "." segments
-            if ( !part || part === '.' ) continue;
-            // Interpret ".." to pop the last segment
-            if ( part === '..' ) {
-                if ( !newParts.length ) backsteps ++;
-                else newParts.pop();
-            }
-            // Push new path segments.
-            else newParts.push( part );
-        }
-        // Preserve the initial slash if there was one.
-        if ( parts[ 0 ] === '' ) newParts.unshift( '' );
-        // Turn back into a single string path.
-        return '../'.repeat( backsteps ) + newParts.join( '/' ) || ( newParts.length ? '/' : '.' );
-    },
-    // A simple function to get the dirname of a path
-    // Trailing slashes are ignored. Leading slash is preserved.
-    dirname( path ) {
-        return this.join( path, '..' );
-    }
-};