@webqit/webflo 0.11.61 → 0.20.2-next.0

package/src/runtime-pi/webflo-fetch/LiveResponse.js

@@ -0,0 +1,437 @@
+import { State, Observer } from '@webqit/quantum-js';
+import { _isObject, _isTypeObject } from '@webqit/util/js/index.js';
+import { publishMutations, applyMutations } from '../webflo-messaging/wq-message-port.js';
+import { responseRealtime } from './response.js';
+import { _wq, _await } from '../../util.js';
+import { isTypeStream } from './util.js';
+
+export class LiveResponse extends EventTarget {
+
+    /* STATIC methods for Input sources */
+
+    static test(data) {
+        if (data instanceof LiveResponse) {
+            return 'LiveResponse';
+        }
+        if (data instanceof Response) {
+            return 'Response';
+        }
+        if (isGenerator(data)) {
+            return 'Generator';
+        }
+        if (data instanceof State) {
+            return 'Quantum';
+        }
+        return 'Default';
+    }
+
+    static from(data, ...args) {
+        if (data instanceof LiveResponse) {
+            return data.clone(...args);
+        }
+        if (data instanceof Response) {
+            return this.fromResponse(data, ...args);
+        }
+        if (isGenerator(data)) {
+            return this.fromGenerator(data, ...args);
+        }
+        if (data instanceof State) {
+            return this.fromQuantum(data, ...args);
+        }
+        return new this(data, ...args);
+    }
+
+    static fromResponse(response, options = {}) {
+        if (!(response instanceof Response)) {
+            throw new Error('Argument must be a Response instance.');
+        }
+        return response.parse().then((body) => {
+            // Instance
+            const instance = new this(body, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                done: false,
+                ...options,
+            });
+            const responseMeta = _wq(response, 'meta');
+            _wq(instance).set('meta', responseMeta);
+            // Generator binding
+            if (response.isLive() === 2) {
+                if (_isTypeObject(body) && !isTypeStream(body)) {
+                    applyMutations.call(response.wqRealtime,
+                        body,
+                        response.headers.get('X-Live-Response-Message-ID').trim(),
+                        { signal: instance.#abortController.signal }
+                    );
+                }
+                // Capture subsequent frames?
+                response.wqRealtime.addEventListener('response.replace', (e) => {
+                    const { body, ...options } = e.data;
+                    instance.#replaceWith(body, options);
+                }, { signal: instance.#abortController.signal });
+                response.wqRealtime.addEventListener('close', () => {
+                    instance.#extendLifecycle(Promise.resolve());
+                }, { once: true, signal: instance.#abortController.signal });
+            }
+            // Data props
+            instance.#type = response.type;
+            instance.#redirected = response.redirected;
+            instance.#url = response.url;
+            // Lifecycle props
+            instance.#generator = response;
+            instance.#generatorType = 'Response';
+            return instance;
+        });
+    }
+
+    static fromGenerator(gen, options = {}) {
+        if (!isGenerator(gen)) {
+            throw new Error('Argument must be a generator or async generator.');
+        }
+        const $firstFrame = gen.next();
+        const instance = _await($firstFrame, (frame) => {
+            return _await(frame.value, (value) => {
+                const $options = { done: frame.done, ...options };
+                let instance, $$await;
+                if (value instanceof Response && frame.done && options.done !== false/* && value.responsesOK*/) {
+                    return value;
+                }
+                if (value instanceof LiveResponse) {
+                    instance = new this;
+                    const responseMeta = _wq(value, 'meta');
+                    _wq(instance).set('meta', responseMeta);
+                    $$await = instance.#replaceWith(value, $options);
+                } else {
+                    instance = this.from/*important*/(value, $options);
+                }
+                return _await(instance, (instance) => {
+                    (async function () {
+                        await $$await;
+                        instance.#generator = gen;
+                        instance.#generatorType = 'Generator';
+                        while (!frame.done && !options.done && !instance.#abortController.signal.aborted) {
+                            frame = await gen.next();
+                            value = await frame.value;
+                            if (!instance.#abortController.signal.aborted) {
+                                await instance.#replaceWith(value, { done: frame.done });
+                            }
+                        }
+                    })();
+                    return instance;
+                });
+            });
+        });
+        return instance;
+    }
+
+    static fromQuantum(qState, options = {}) {
+        if (!(qState instanceof State)) {
+            throw new Error('Argument must be a Quantum State instance.');
+        }
+        const instance = new this(qState.value, { done: false, ...options });
+        instance.#generator = qState;
+        instance.#generatorType = 'Quantum';
+        Observer.observe(
+            qState,
+            'value',
+            (e) => instance.#replaceWith(e.value),
+            { signal: instance.#abortController.signal }
+        );
+        return instance;
+    }
+
+    #generator = null;
+    #generatorType = 'Default';
+    get generatorType() { return this.#generatorType; }
+
+    #abortController = new AbortController;
+
+    disconnect() {
+        // Disconnection from existing generator
+        this.#abortController.abort();
+        this.#generator = null;
+        this.#generatorType = 'Default';
+        // and a new signal system
+        this.#abortController = new AbortController;
+    }
+
+    /* INSTANCE */
+
+    constructor(body, ...args) {
+        super();
+        this.#replaceWith(body, ...args);
+    }
+
+    /* Level 1 props */
+
+    body = null; // Managed at #replaceWith()
+
+    #headers = new Headers;
+    get headers() { return this.#headers; }
+
+    #status = 200;
+    get status() { return this.#status; }
+
+    #statusText = '';
+    get statusText() { return this.#statusText; }
+
+    get ok() { return this.#status >= 200 && this.#status < 299; }
+
+    get bodyUsed() { return false; }
+
+    /* Level 2 props */
+
+    #type = 'basic';
+    get type() { return this.#type; }
+
+    #redirected = false;
+    get redirected() { return this.#redirected; }
+
+    #url = null;
+    get url() { return this.#url; }
+
+    /* Level 3 props */
+
+    get wqRealtime() {
+        return responseRealtime.call(this);
+    }
+
+    /* Lifecycle methods */
+
+    isLive() {
+        let liveLevel = (this.headers.get('X-Background-Messaging-Port')?.trim() || _wq(this, 'meta').has('wqRealtime')) && 1 || 0;
+        liveLevel += this.headers.get('X-Live-Response-Message-ID')?.trim() && 1 || 0;
+        return liveLevel;
+    }
+
+    whileLive(returningThePromise = false) {
+        if (returningThePromise) {
+            return this.#lifeCycleResolutionPromise;
+        }
+        return this.#currentFramePromise !== null;
+    }
+
+    #currentFramePromise;
+    #lifeCycleResolve;
+    #lifeCycleReject;
+    #lifeCycleResolutionPromise = new Promise((resolve, reject) => {
+        this.#lifeCycleResolve = resolve;
+        this.#lifeCycleReject = reject;
+    });
+
+    #extendLifecycle(promise) {
+        if (this.#currentFramePromise === null) {
+            throw new Error('Event lifecycle already complete.');
+        }
+        this.#currentFramePromise = promise;
+        promise.then((value) => {
+            if (this.#currentFramePromise === promise) {
+                this.#currentFramePromise = null;
+                this.#lifeCycleResolve(value);
+            }
+        }).catch((e) => {
+            if (this.#currentFramePromise === promise) {
+                this.#currentFramePromise = null;
+                this.#lifeCycleReject(e);
+            }
+        });
+    }
+
+    async #replaceWith(body, ...args) {
+
+        if (body instanceof Promise) {
+            this.#extendLifecycle(body);
+            return await new Promise((resolve, reject) => {
+                let aborted = false;
+                this.#abortController.signal.addEventListener('abort', () => {
+                    aborted = true
+                    resolve();
+                });
+                body.then(async (resolveData) => {
+                    resolve();
+                    if (aborted) return;
+                    await this.#replaceWith(resolveData, ...args);
+                });
+                body.catch((e) => reject(e));
+            });
+        }
+
+        const options = _isObject(args[0]/* !ORDER 1 */) ? { ...args.shift() } : {};
+        const frameClosure = typeof args[0]/* !ORDER 2 */ === 'function' ? args.shift() : null;
+
+        if ('status' in options) {
+            options.status = parseInt(options.status);
+            if (options.status < 200 || options.status > 599) {
+                throw new Error(`The status provided (${options.status}) is outside the range [200, 599].`);
+            }
+        }
+        if ('statusText' in options) {
+            options.statusText = String(options.statusText);
+        }
+        if (options.headers && !(options.headers instanceof Headers)) {
+            options.headers = new Headers(options.headers);
+        }
+
+        const execReplaceWith = (responseLike) => {
+            const $body = responseLike.body;
+            this.#status = responseLike.status;
+            this.#statusText = responseLike.statusText;
+            for (const [name] of [/*IMPORTANT*/...this.#headers.entries()]) { // for some reason, some entries not produced when not spread
+                this.#headers.delete(name);
+            }
+            for (const [name, value] of responseLike.headers.entries()) {
+                this.#headers.append(name, value);
+            }
+            this.#type = responseLike.type;
+            this.#redirected = responseLike.redirected;
+            this.#url = responseLike.url;
+            // Must come after all property assignments above because it fires events
+            Observer.defineProperty(this, 'body', { get: () => $body, enumerable: true, configurable: true });
+            this.dispatchEvent(new Event('replace'));
+        };
+
+        const execReplaceWithResponse = async (response, options) => {
+            this.#generator = response;
+            this.#generatorType = response instanceof Response ? 'Response' : 'LiveResponse';
+            execReplaceWith({
+                body: response instanceof Response ? await response.parse() : response.body,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                ...options,
+                type: response.type,
+                redirected: response.redirected,
+                url: response.url,
+            });
+            if (response instanceof LiveResponse) {
+                response.addEventListener('replace', () => execReplaceWith(response), { signal: this.#abortController.signal });
+                return await response.whileLive(true);
+            }
+            return Promise.resolve();
+        };
+
+        const execReplaceWithBody = async (body, options) => {
+            execReplaceWith({
+                body,
+                status: 200,
+                statusText: '',
+                headers: new Headers,
+                ...options,
+                type: 'basic',
+                redirected: false,
+                url: null
+            });
+            if (frameClosure) {
+                const reactiveProxy = _isTypeObject(body) && !isTypeStream(body)
+                    ? Observer.proxy(body, { chainable: true, membrane: body })
+                    : body;
+                return await frameClosure.call(this, reactiveProxy);
+            }
+            return Promise.resolve();
+        };
+
+        let donePromise;
+        if (body instanceof Response || body instanceof LiveResponse) {
+            if (frameClosure) {
+                throw new Error('frameClosure unsupported for inputs of type response.');
+            }
+            donePromise = execReplaceWithResponse(body, options);
+        } else {
+            donePromise = execReplaceWithBody(body, options);
+        }
+
+        if (options.done === false) {
+            this.#extendLifecycle(new Promise(() => { }));
+        } else {
+            this.#extendLifecycle(donePromise);
+        }
+
+        return await new Promise((resolve, reject) => {
+            this.#abortController.signal.addEventListener('abort', resolve);
+            donePromise.then(() => resolve());
+            donePromise.catch((e) => reject(e));
+        });
+    }
+
+    async replaceWith(body, ...args) {
+        if (!this.whileLive()) {
+            throw new Error(`Instance already "complete".`);
+        }
+        this.disconnect(); // Disconnect from existing source if any
+        await this.#replaceWith(body, ...args);
+    }
+
+    toResponse({ clientRequestRealtime, signal: abortSignal } = {}) {
+        const response = Response.from(this.body, {
+            status: this.status,
+            statusText: this.statusText,
+            headers: this.headers,
+        });
+        const responseMeta = _wq(this, 'meta');
+        _wq(response).set('meta', responseMeta);
+        if (clientRequestRealtime && this.whileLive()) {
+            const liveResponseMessageID = Date.now().toString();
+            response.headers.set('X-Live-Response-Message-ID', liveResponseMessageID);
+            // Publish mutations
+            if (_isTypeObject(this.body) && !isTypeStream(this.body)) {
+                publishMutations.call(clientRequestRealtime, this.body, liveResponseMessageID, { signal: abortSignal/* stop observing mutations on body when we abort */ });
+            }
+            // Publish replacements?
+            const replaceHandler = () => {
+                const headers = Object.fromEntries([...this.headers.entries()]);
+                if (headers?.['set-cookie']) {
+                    delete headers['set-cookie'];
+                    console.warn('Warning: The "set-cookie" header is not supported for security reasons and has been removed from the response.');
+                }
+                clientRequestRealtime.postMessage({
+                    body: this.body,
+                    status: this.status,
+                    statusText: this.statusText,
+                    headers,
+                    done: !this.whileLive(),
+                }, { wqEventOptions: { type: 'response.replace', live: true/*gracefully ignored if not an object*/ }, observerOptions: { signal: abortSignal/* stop observing mutations on body when we abort */ } });
+            };
+            this.addEventListener('replace', replaceHandler, { signal: abortSignal/* stop listening when we abort */ });
+        }
+        return response;
+    }
+
+    async * toGenerator({ signal: abortSignal } = {}) {
+        do {
+            yield $this.body;
+        } while (await new Promise((resolve) => {
+            this.addEventListener('replace', () => resolve(true), { once: true, signal: abortSignal });
+            this.whileLive(true).then(() => resolve(false));
+        }));
+    }
+
+    toQuantum({ signal: abortSignal } = {}) {
+        const state = new StateX;
+        const replaceHandler = () => Observer.defineProperty(state, 'value', { value: this.body, enumerable: true, configurable: true });
+        this.addEventListener('replace', replaceHandler, { signal: abortSignal });
+        replaceHandler();
+        return state;
+    }
+
+    clone(init = {}) {
+        const clone = new this.constructor();
+        const responseMeta = _wq(this, 'meta');
+        _wq(clone).set('meta', responseMeta);
+        clone.replaceWith(this, init);
+        return clone;
+    }
+}
+
+export const isGenerator = (obj) => {
+    return typeof obj?.next === 'function' &&
+        typeof obj?.throw === 'function' &&
+        typeof obj?.return === 'function';
+};
+
+class StateX extends State {
+    constructor() { }
+    dispose() { }
+}
+
+globalThis.LiveResponse = LiveResponse;

package/src/runtime-pi/webflo-fetch/cookies.js

@@ -0,0 +1,10 @@
+export function renderCookieObjToString(cookieObj) {
+    const attrsArr = [`${cookieObj.name}=${/*encodeURIComponent*/(cookieObj.value)}`];
+    for (const attrName in cookieObj) {
+        if (['name', 'value'].includes(attrName)) continue;
+        let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
+        if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
+        attrsArr.push(cookieObj[attrName] === true ? _attrName : `${_attrName}=${cookieObj[attrName]}`);
+    }
+    return attrsArr.join(';');
+}

package/src/runtime-pi/webflo-fetch/fetch.js

@@ -0,0 +1,16 @@
+import { renderHttpMessageInit } from './message.js';
+
+const nativeFetch = fetch;
+export async function fetch(url, init = {}) {
+    return await nativeFetch(url);
+    if (init.body) {
+        const { body, headers } = renderHttpMessageInit(init);
+        init = { ...init, body, headers, };
+    }
+    let response = await nativeFetch(url, init), encoding;
+    if (init.decompress === false && (encoding = response.headers.get('Content-Encoding'))) {
+        const recompressedBody = response.body.pipeThrough(new CompressionStream(encoding));
+        response = new Response(recompressedBody, response);
+    }
+    return response;
+}

package/src/runtime-pi/webflo-fetch/formdata.js

@@ -0,0 +1,54 @@
+
+import { _isNumeric } from '@webqit/util/js/index.js';
+import { _before } from '@webqit/util/str/index.js';
+import { DeepURLSearchParams } from '../webflo-url/util.js';
+import { dataType } from './util.js';
+
+export function createFormDataFromJson(data = {}, jsonfy = true, getIsJsonfiable = false) {
+    const formData = new FormData;
+    let isJsonfiable = true;
+    DeepURLSearchParams.reduceValue(data, '', (value, contextPath, suggestedKeys = undefined) => {
+        if (suggestedKeys) {
+            const isJson = dataType(value) === 'json';
+            isJsonfiable = isJsonfiable && isJson;
+            return isJson && suggestedKeys;
+        }
+        if (jsonfy && [true, false, null].includes(value)) {
+            value = new Blob([value], { type: 'application/json' });
+        }
+        formData.append(contextPath, value);
+    });
+    if (getIsJsonfiable) return [formData, isJsonfiable];
+    return formData;
+}
+
+export async function renderFormDataToJson(formData, jsonfy = true, getIsJsonfiable = false) {
+    let isJsonfiable = true;
+    let json;
+    for (let [name, value] of formData.entries()) {
+        if (!json) { json = _isNumeric(_before(name, '[')) ? [] : {}; }
+        let type = dataType(value);
+        if (jsonfy && ['Blob', 'File'].includes(type) && value.type === 'application/json') {
+            let _value = await value.text();
+            value = JSON.parse(_value);
+            type = 'json';
+        }
+        isJsonfiable = isJsonfiable && type === 'json';
+        DeepURLSearchParams.set(json, name, value);
+    }
+    if (getIsJsonfiable) return [json, isJsonfiable];
+    return json;
+}
+
+Object.defineProperties(FormData, {
+    json: { value: createFormDataFromJson }
+});
+
+Object.defineProperties(FormData.prototype, {
+    json: {
+        value: async function (data = {}) {
+            const result = await renderFormDataToJson(this, ...arguments);
+            return result;
+        }
+    }
+});

package/src/runtime-pi/webflo-fetch/headers.js

@@ -0,0 +1,151 @@
+import { _after } from '@webqit/util/str/index.js';
+import { _isObject, _isTypeObject } from '@webqit/util/js/index.js';
+import { _from as _arrFrom } from '@webqit/util/arr/index.js';
+import { renderCookieObjToString } from './cookies.js';
+
+const prototypeOriginals = {
+    set: Headers.prototype.set,
+    get: Headers.prototype.get,
+    append: Headers.prototype.append,
+};
+const prototypeExtensions = {
+    set: {
+        value: function (name, value) {
+            // -------------------------
+            // Format "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+                value = renderCookieObjToString(value);
+            }
+            // -------------------------
+            // Format "Cookie" request header
+            if (/Cookie/i.test(name) && _isTypeObject(value)) {
+                value = [].concat(value).map(renderCookieObjToString).join(';');
+            }
+            // -------------------------
+            // Format "Content-Range" response header?
+            if (/^Content-Range$/i.test(name) && Array.isArray(value)) {
+                if (value.length < 2 || !value[0].includes('-')) {
+                    throw new Error(`A Content-Range array must be in the format: [ 'start-end', 'total' ]`);
+                }
+                value = `bytes ${value.join('/')}`;
+            }
+            // -------------------------
+            // Format "Range" request header?
+            if (/^Range$/i.test(name)) {
+                let rangeArr = [];
+                _arrFrom(value).forEach((range, i) => {
+                    let rangeStr = Array.isArray(range) ? range.join('-') : range + '';
+                    if (i === 0 && !rangeStr.includes('bytes=')) {
+                        rangeStr = `bytes=${rangeStr}`;
+                    }
+                    rangeArr.push(rangeStr);
+                });
+                value = rangeArr.join(', ');
+            }
+            // -------------------------
+            // Format "Accept" request header?
+            if (/^Accept$/i.test(name) && Array.isArray(value)) {
+                value = value.join(',');
+            }
+            // -------------------------
+            return prototypeOriginals.set.call(this, name, value);
+        }
+    },
+    append: {
+        value: function (name, value) {
+            // -------------------------
+            // Format "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && _isObject(value)) {
+                value = renderCookieObjToString(value);
+            }
+            // -------------------------
+            return prototypeOriginals.append.call(this, name, value);
+        }
+    },
+    get: {
+        value: function (name, parsed = false) {
+            let value = prototypeOriginals.get.call(this, name);
+            // -------------------------
+            // Parse "Set-Cookie" response header
+            if (/^Set-Cookie$/i.test(name) && parsed) {
+                value = this.getSetCookie()/*IMPORTANT*/.map((str) => {
+                    const [cookieDefinition, attrsStr] = str.split(';');
+                    const [name, value] = cookieDefinition.split('=').map((s) => s.trim());
+                    const cookieObj = { name, value: /*decodeURIComponent*/(value), };
+                    attrsStr && attrsStr.split(/\;/g).map(attrStr => attrStr.trim().split('=')).forEach(attrsArr => {
+                        cookieObj[attrsArr[0][0].toLowerCase() + attrsArr[0].substring(1).replace('-', '')] = attrsArr.length === 1 ? true : attrsArr[1];
+                    });
+                    return cookieObj;
+                });
+            }
+            // -------------------------
+            // Parse "Cookie" request header
+            if (/^Cookie$/i.test(name) && parsed) {
+                value = value?.split(';').map((str) => {
+                    const [name, value] = str.split('=').map((s) => s.trim());
+                    return { name, value: /*decodeURIComponent*/(value), };
+                }) || [];
+            }
+            // -------------------------
+            // Parse "Content-Range" response header?
+            if (/^Content-Range$/i.test(name) && value && parsed) {
+                value = _after(value, 'bytes ').split('/');
+            }
+            // -------------------------
+            // Parse "Range" request header?
+            if (/^Range$/i.test(name) && parsed) {
+                value = !value ? [] : _after(value, 'bytes=').split(',').map((rangeStr) => {
+                    const range = rangeStr.trim().split('-').map((s) => s ? parseInt(s, 10) : null);
+                    range.render = (totalLength) => {
+                        if (range[1] === null) {
+                            range[1] = totalLength - 1;
+                        }
+                        if (range[0] === null) {
+                            range[0] = range[1] ? totalLength - range[1] - 1 : 0;
+                        }
+                        return range
+                    };
+                    range.isValid = (currentStart, totalLength) => {
+                        // Start higher than end or vice versa?
+                        if (range[0] > range[1] || range[1] < range[0]) return false;
+                        // Stretching beyond valid start/end?
+                        if (range[0] < currentStart || range[1] > totalLength) return false;
+                        return true;
+                    };
+                    return range;
+                });
+            }
+            // -------------------------
+            // Parse "Accept" request header?
+            if (/^Accept$/i.test(name) && value && parsed) {
+                const parseSpec = (spec) => {
+                    const [mime, q] = spec.trim().split(';').map((s) => s.trim());
+                    return [mime, parseFloat((q || 'q=1').replace('q=', ''))];
+                };
+                const list = value.split(',')
+                    .map((spec) => parseSpec(spec))
+                    .sort((a, b) => a[1] > b[1] ? -1 : 1) || [];
+                const $value = value;
+                value = {
+                    match(mime) {
+                        if (!mime) return 0;
+                        const splitMime = (mime) => mime.split('/').map((s) => s.trim());
+                        const $mime = splitMime(mime + '');
+                        return list.reduce((prev, [entry, q]) => {
+                            if (prev) return prev;
+                            const $entry = splitMime(entry);
+                            return [0, 1].every((i) => (($mime[i] === $entry[i]) || $mime[i] === '*' || $entry[i] === '*')) ? q : 0;
+                        }, 0);
+                    },
+                    toString() {
+                        return $value;
+                    }
+                };
+            }
+            // -------------------------
+            return value;
+        }
+    }
+};
+
+Object.defineProperties(Headers.prototype, prototypeExtensions);

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

@@ -0,0 +1,5 @@
+import './formdata.js';
+import './request.js';
+import './response.js';
+import './LiveResponse.js';
+import './headers.js';