@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/dist/esm/session/request.mjs

@@ -0,0 +1,231 @@
+import { identityCacheKey } from "../identity.mjs";
+import { permitsDocumentCache, policyHeaders } from "./cache.mjs";
+function freezeResponsePolicy(policy) {
+    if (!Number.isInteger(policy.status) || policy.status < 200 || policy.status > 599) throw new TypeError('A renderer response status must be an integer from 200 to 599.');
+    if ('document' !== policy.kind && 'terminal' !== policy.kind) throw new TypeError('A renderer response must identify its document or terminal outcome.');
+    const statusText = policy.statusText;
+    if (void 0 !== statusText && 'string' != typeof statusText) throw new TypeError('A renderer response status text must be a string.');
+    new Response(null, {
+        status: policy.status,
+        ...void 0 === statusText ? {} : {
+            statusText
+        }
+    });
+    if (![
+        'no-store',
+        'private',
+        'public'
+    ].includes(policy.cache.mode)) throw new TypeError('A renderer response has an unknown cache policy.');
+    if ('public' === policy.cache.mode && (!Number.isInteger(policy.cache.maxAgeSeconds) || policy.cache.maxAgeSeconds < 0)) throw new TypeError('A public document cache lifetime must be a nonnegative integer.');
+    const headers = policy.headers.map(([name, value])=>{
+        new Headers([
+            [
+                name,
+                value
+            ]
+        ]);
+        return Object.freeze([
+            name,
+            value
+        ]);
+    });
+    return Object.freeze({
+        kind: policy.kind,
+        status: policy.status,
+        ...void 0 === statusText ? {} : {
+            statusText
+        },
+        headers: Object.freeze(headers),
+        cache: Object.freeze({
+            ...policy.cache
+        })
+    });
+}
+function createRequestSession(input) {
+    identityCacheKey(input.identity);
+    if ('node' !== input.platform.kind && 'worker' !== input.platform.kind) throw new TypeError('A renderer request requires an explicit Node or worker binding.');
+    const identity = Object.freeze({
+        ...input.identity
+    });
+    const platform = Object.freeze({
+        ...input.platform
+    });
+    const abortController = new AbortController();
+    const disposers = new Set();
+    let state = 'matching';
+    let policy;
+    let committedPolicy;
+    let fallback = false;
+    let responseCreated = false;
+    let hasDocumentBody = false;
+    let deliveredResponse;
+    let deliveredHeaders;
+    let reader;
+    let bodyController;
+    let cancelPromise;
+    let finishPromise;
+    let resolveCompletion;
+    const completion = new Promise((resolve)=>{
+        resolveCompletion = resolve;
+    });
+    const cancelSource = (reason)=>{
+        cancelPromise ??= reader ? reader.cancel(reason).finally(()=>reader?.releaseLock()) : Promise.resolve();
+        return cancelPromise;
+    };
+    const finish = (terminalState, error)=>{
+        if (finishPromise) return finishPromise;
+        state = terminalState;
+        input.request.signal.removeEventListener('abort', onRequestAbort);
+        const ownedDisposers = [
+            ...disposers
+        ].reverse();
+        disposers.clear();
+        finishPromise = Promise.resolve().then(async ()=>{
+            const cleanupErrors = [];
+            let recorded = false;
+            if ('completed' !== terminalState) cancelSource(error).catch((cancelError)=>{
+                if (!recorded) cleanupErrors.push(cancelError);
+            });
+            for (const dispose of ownedDisposers)try {
+                await dispose();
+            } catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+            await Promise.resolve();
+            recorded = true;
+            if ('completed' === terminalState && cleanupErrors.length > 0) state = 'failed';
+            const result = Object.freeze({
+                state: state,
+                fallback,
+                ...void 0 !== error ? {
+                    error
+                } : {},
+                cleanupErrors: Object.freeze(cleanupErrors),
+                cacheEligible: 'completed' === state && hasDocumentBody && !fallback && void 0 !== committedPolicy && permitsDocumentCache({
+                    ...committedPolicy,
+                    headers: deliveredHeaders ? [
+                        ...deliveredHeaders.entries()
+                    ] : committedPolicy.headers
+                })
+            });
+            resolveCompletion(result);
+            return result;
+        });
+        if ('completed' !== terminalState) {
+            abortController.abort(error);
+            bodyController?.error(error);
+        }
+        return finishPromise;
+    };
+    const abort = (reason = new DOMException('The renderer request was aborted.', 'AbortError'))=>{
+        finish('aborted', reason);
+    };
+    function onRequestAbort() {
+        abort(input.request.signal.reason);
+    }
+    const session = {
+        request: input.request,
+        identity,
+        platform,
+        signal: abortController.signal,
+        get state () {
+            return state;
+        },
+        get responsePolicy () {
+            return policy;
+        },
+        get committedPolicy () {
+            return committedPolicy;
+        },
+        completion,
+        resolveResponse (nextPolicy) {
+            if (committedPolicy || finishPromise) throw new Error('Renderer response status and headers are already committed or terminated.');
+            policy = freezeResponsePolicy(nextPolicy);
+            if ('matching' === state) state = 'ready';
+        },
+        startRendering () {
+            if ('ready' !== state) throw new Error('Resolve the blocking HTTP outcome before starting the renderer.');
+            state = 'rendering';
+        },
+        registerCleanup (dispose) {
+            if (finishPromise) throw new Error('Cannot register cleanup after a renderer request terminates.');
+            disposers.add(dispose);
+            return ()=>{
+                disposers.delete(dispose);
+            };
+        },
+        markFallback () {
+            if (finishPromise) throw new Error('Cannot change fallback disposition after a renderer request terminates.');
+            fallback = true;
+        },
+        respond (body) {
+            if (responseCreated || committedPolicy || finishPromise) throw new Error('A renderer request has exactly one response body consumer.');
+            if (!policy || 'ready' !== state && 'rendering' !== state) throw new Error('Resolve the blocking HTTP outcome before committing a response.');
+            if (null !== body && [
+                204,
+                205,
+                304
+            ].includes(policy.status)) throw new TypeError(`HTTP ${policy.status} cannot contain a renderer response body.`);
+            reader = body?.getReader();
+            hasDocumentBody = null !== body;
+            responseCreated = true;
+            committedPolicy = policy;
+            state = 'committed';
+            const headers = policyHeaders(committedPolicy.headers);
+            let wrappedBody = null;
+            if (reader) {
+                const sourceReader = reader;
+                wrappedBody = new ReadableStream({
+                    start (controller) {
+                        bodyController = controller;
+                    },
+                    async pull (controller) {
+                        try {
+                            const next = await sourceReader.read();
+                            if (finishPromise) return;
+                            if (!next.done) return void controller.enqueue(next.value);
+                            sourceReader.releaseLock();
+                            const result = await finish('completed');
+                            if (result.cleanupErrors.length > 0) controller.error(new AggregateError(result.cleanupErrors, 'Renderer request cleanup failed.'));
+                            else controller.close();
+                        } catch (error) {
+                            if (!finishPromise) {
+                                await finish('failed', error);
+                                controller.error(error);
+                            }
+                        }
+                    },
+                    cancel (reason) {
+                        abort(reason);
+                        return completion.then(()=>{});
+                    }
+                }, {
+                    highWaterMark: 0
+                });
+            } else finish('completed');
+            const response = new Response(wrappedBody, {
+                status: committedPolicy.status,
+                ...void 0 === committedPolicy.statusText ? {} : {
+                    statusText: committedPolicy.statusText
+                },
+                headers
+            });
+            deliveredResponse = response;
+            deliveredHeaders = response.headers;
+            return response;
+        },
+        ownsResponseBody (response) {
+            return void 0 !== deliveredResponse && (response === deliveredResponse || null !== deliveredResponse.body && response.body === deliveredResponse.body);
+        },
+        fail (error) {
+            finish('failed', error);
+        },
+        abort
+    };
+    if (input.request.signal.aborted) onRequestAbort();
+    else input.request.signal.addEventListener('abort', onRequestAbort, {
+        once: true
+    });
+    return session;
+}
+export { createRequestSession };

package/dist/esm-node/abort.mjs

@@ -0,0 +1,28 @@
+import "node:module";
+function untilAborted(handled, signal) {
+    const settled = Promise.resolve(handled);
+    const discard = ()=>void settled.then((value)=>{
+            if (value instanceof Response) value.body?.cancel().catch(()=>{});
+        }, ()=>{});
+    if (signal.aborted) {
+        discard();
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>{
+            discard();
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        settled.then((value)=>{
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error)=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+export { untilAborted };

package/dist/esm-node/adapter.mjs

@@ -0,0 +1,22 @@
+import "node:module";
+const adapterError = (name, detail)=>new Error(`Invalid renderer adapter ${String(name)}: ${detail}`);
+function defineRendererAdapter(adapter) {
+    const { name, profile } = adapter;
+    if (profile.renderer !== name) throw adapterError(name, `profile names ${profile.renderer}`);
+    if (!adapter.routerFrameworks.length) throw adapterError(name, 'it declares no router framework');
+    if (adapter.worker.rsc !== profile.capabilities.rsc) throw adapterError(name, 'worker RSC support contradicts its profile');
+    if ('native' === adapter.kind) {
+        if (true !== adapter.worker.nativeDocuments) throw adapterError(name, 'native documents come from its server handler');
+        const federation = adapter.federation;
+        const capability = profile.capabilities.moduleFederation;
+        if (void 0 === federation !== (false === capability) || void 0 !== federation && federation.ssr !== (true === capability)) throw adapterError(name, 'federation support contradicts its profile');
+    }
+    return Object.freeze(adapter);
+}
+function nativeRendererDependencies(profile) {
+    return {
+        ...Object.fromEntries(Object.entries(profile.dependencies).filter(([name])=>!name.startsWith('@modern-js/'))),
+        [profile.router.coreName]: profile.router.coreVersion
+    };
+}
+export { defineRendererAdapter, nativeRendererDependencies };

package/dist/esm-node/data/body.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+import { DataProtocolError, MAX_DATA_BYTES } from "./codec.mjs";
+async function readBoundedDataText(response, signal, maxBytes = MAX_DATA_BYTES) {
+    if (signal?.aborted) {
+        response.body?.cancel(signal.reason).catch(()=>void 0);
+        signal.throwIfAborted();
+    }
+    if (!response.body) return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    let bytes = 0;
+    let text = '';
+    const abort = ()=>{
+        reader.cancel(signal?.reason).catch(()=>void 0);
+    };
+    signal?.addEventListener('abort', abort, {
+        once: true
+    });
+    try {
+        while(true){
+            const result = await reader.read();
+            signal?.throwIfAborted();
+            if (result.done) break;
+            bytes += result.value.byteLength;
+            if (bytes > maxBytes) throw new DataProtocolError('Public data exceeds its byte limit');
+            text += decoder.decode(result.value, {
+                stream: true
+            });
+        }
+        return text + decoder.decode();
+    } catch (error) {
+        reader.cancel(error).catch(()=>void 0);
+        throw error;
+    } finally{
+        signal?.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+}
+export { readBoundedDataText };