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

package/dist/esm/data/static.mjs

@@ -0,0 +1,51 @@
+import { MAX_DATA_BYTES } from "./codec.mjs";
+import { DATA_CONTENT_TYPE, DATA_STREAM_CONTENT_TYPE } from "./types.mjs";
+const PRERENDERED_DOCUMENT_META = 'ultramodern-prerendered';
+const STATIC_DATA_DIRECTORY = '__ultramodern-data';
+function encodeRouteId(routeId) {
+    let binary = '';
+    for (const byte of new TextEncoder().encode(routeId))binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/u, '');
+}
+function staticDataPayloadPath(pathname, routeId) {
+    if (!routeId) throw new TypeError('A static data payload needs a route ID');
+    const directory = pathname.endsWith('/') ? pathname : `${pathname}/`;
+    return `${directory}${STATIC_DATA_DIRECTORY}/${encodeRouteId(routeId)}.json`;
+}
+const STATIC_DATA_PAYLOAD_MAX_BYTES = 6 * MAX_DATA_BYTES + 1024;
+const payloadTooLarge = (bytes)=>new RangeError(`A static loader payload of ${bytes} bytes exceeds the ${STATIC_DATA_PAYLOAD_MAX_BYTES} bytes the data client replays; reduce its (deferred) data or serve the route dynamically.`);
+async function readStaticDataPayloadBody(response) {
+    if (!response.body) return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    let text = '';
+    for(;;){
+        const part = await reader.read();
+        if (part.done) return text + decoder.decode();
+        bytes += part.value.byteLength;
+        if (bytes > STATIC_DATA_PAYLOAD_MAX_BYTES) {
+            const error = payloadTooLarge(`more than ${bytes}`);
+            reader.cancel(error).catch(()=>{});
+            throw error;
+        }
+        text += decoder.decode(part.value, {
+            stream: true
+        });
+    }
+}
+function encodeStaticDataPayload(payload) {
+    const text = JSON.stringify(payload);
+    const bytes = new TextEncoder().encode(text).byteLength;
+    if (bytes > STATIC_DATA_PAYLOAD_MAX_BYTES) throw payloadTooLarge(bytes);
+    return text;
+}
+function isStaticDataPayload(value) {
+    if (null === value || 'object' != typeof value || Array.isArray(value)) return false;
+    const payload = value;
+    return Number.isInteger(payload.status) && payload.status >= 200 && payload.status <= 599 && (payload.contentType === DATA_CONTENT_TYPE || payload.contentType === DATA_STREAM_CONTENT_TYPE) && 'string' == typeof payload.body;
+}
+function isPrerenderedDocument() {
+    return "u" > typeof document && null !== document.querySelector(`meta[name="${PRERENDERED_DOCUMENT_META}"]`);
+}
+export { PRERENDERED_DOCUMENT_META, STATIC_DATA_DIRECTORY, STATIC_DATA_PAYLOAD_MAX_BYTES, encodeStaticDataPayload, isPrerenderedDocument, isStaticDataPayload, readStaticDataPayloadBody, staticDataPayloadPath };

package/dist/esm/data/tree.mjs

@@ -0,0 +1,193 @@
+const MAX_NODES = 20000;
+const MAX_DEPTH = 300;
+function record(value) {
+    if (null === value || 'object' != typeof value || Object.getPrototypeOf(value) !== Object.prototype && null !== Object.getPrototypeOf(value)) throw new TypeError('Malformed public data tree record');
+    return value;
+}
+function exactFields(value, fields) {
+    if (Reflect.ownKeys(value).length !== fields.length || fields.some((field)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(value, field);
+        return void 0 === descriptor || !('value' in descriptor);
+    })) throw new TypeError('Malformed public data node fields');
+}
+function integer(value, maximum) {
+    return 'number' == typeof value && Number.isInteger(value) && value >= 0 && value <= maximum;
+}
+function nodeArray(value) {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || value.length > MAX_NODES || Reflect.ownKeys(value).length !== value.length + 1) throw new TypeError('Malformed or oversized public data node array');
+    for(let index = 0; index < value.length; index++){
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !('value' in descriptor)) throw new TypeError('Public data node arrays must be dense values');
+    }
+    return value;
+}
+function pairs(value) {
+    const entry = record(value);
+    exactFields(entry, [
+        'k',
+        'v'
+    ]);
+    const keys = nodeArray(entry.k);
+    const values = nodeArray(entry.v);
+    if (keys.length !== values.length) throw new TypeError('Public data keys and values have different lengths');
+    return {
+        k: keys,
+        v: values
+    };
+}
+function validateSerializedData(value) {
+    const tree = record(value);
+    exactFields(tree, [
+        't',
+        'f',
+        'm'
+    ]);
+    if (!integer(tree.f, 127)) throw new TypeError('Malformed public data feature flags');
+    const metadata = nodeArray(tree.m);
+    if (metadata.some((id)=>!integer(id, MAX_NODES)) || new Set(metadata).size !== metadata.length) throw new TypeError('Malformed public data reference metadata');
+    const declarations = new Map();
+    let count = 0;
+    const declare = (id, tag)=>{
+        if (!integer(id, MAX_NODES)) throw new TypeError('Malformed public data reference id');
+        if (declarations.has(id)) throw new TypeError('Duplicate public data reference id');
+        declarations.set(id, tag);
+    };
+    const visit = (input, depth, mapSentinel = false)=>{
+        if (++count > MAX_NODES || depth > MAX_DEPTH) throw new TypeError('Public data tree exceeds its size or depth limit');
+        const node = record(input);
+        const tagDescriptor = Object.getOwnPropertyDescriptor(node, 't');
+        if (!tagDescriptor || !('value' in tagDescriptor) || !integer(tagDescriptor.value, 26)) throw new TypeError('Malformed public data node tag');
+        const tag = tagDescriptor.value;
+        if (mapSentinel && 4 !== tag && 26 !== tag) throw new TypeError('Malformed public data Map sentinel');
+        switch(tag){
+            case 0:
+                exactFields(node, [
+                    't',
+                    's'
+                ]);
+                if ('number' != typeof node.s || !Number.isFinite(node.s)) throw new TypeError('Malformed public data number');
+                return;
+            case 1:
+                exactFields(node, [
+                    't',
+                    's'
+                ]);
+                if ('string' != typeof node.s) throw new TypeError('Malformed public data string');
+                return;
+            case 2:
+                exactFields(node, [
+                    't',
+                    's'
+                ]);
+                if (!integer(node.s, 7)) throw new TypeError('Malformed public data constant');
+                return;
+            case 3:
+                exactFields(node, [
+                    't',
+                    's'
+                ]);
+                if ('string' != typeof node.s || node.s.length > 10000 || !/^-?(?:0|[1-9]\d*)$/.test(node.s)) throw new TypeError('Malformed public data bigint');
+                return;
+            case 4:
+                exactFields(node, [
+                    't',
+                    'i'
+                ]);
+                if (!integer(node.i, MAX_NODES) || !declarations.has(node.i)) throw new TypeError('Missing or forward public data reference');
+                if (26 === declarations.get(node.i) !== mapSentinel) throw new TypeError('Public data references a Map sentinel as a value');
+                return;
+            case 5:
+                exactFields(node, [
+                    't',
+                    'i',
+                    's'
+                ]);
+                if ('string' != typeof node.s) throw new TypeError('Malformed public data date');
+                if ('' !== node.s) {
+                    const timestamp = new Date(node.s);
+                    if (!Number.isFinite(timestamp.getTime()) || timestamp.toISOString() !== node.s) throw new TypeError('Malformed public data date');
+                }
+                declare(node.i, tag);
+                return;
+            case 6:
+                exactFields(node, [
+                    't',
+                    'i',
+                    'c',
+                    'm'
+                ]);
+                if ('string' != typeof node.c || 'string' != typeof node.m || !/^[dgimsuvy]*$/.test(node.m) || new Set(node.m).size !== node.m.length || node.m.includes('u') && node.m.includes('v')) throw new TypeError('Malformed public data regular expression');
+                declare(node.i, tag);
+                return;
+            case 7:
+                exactFields(node, [
+                    't',
+                    'i',
+                    'a'
+                ]);
+                declare(node.i, tag);
+                for (const item of nodeArray(node.a))visit(item, depth + 1);
+                return;
+            case 8:
+                {
+                    exactFields(node, [
+                        't',
+                        'i',
+                        'e',
+                        'f'
+                    ]);
+                    declare(node.i, tag);
+                    const entries = pairs(node.e);
+                    for(let index = 0; index < entries.k.length; index++){
+                        visit(entries.k[index], depth + 1);
+                        visit(entries.v[index], depth + 1);
+                    }
+                    visit(node.f, depth + 1, true);
+                    return;
+                }
+            case 9:
+                exactFields(node, [
+                    't',
+                    'i',
+                    'a',
+                    'o'
+                ]);
+                if (!integer(node.o, 3)) throw new TypeError('Malformed public data object flags');
+                declare(node.i, tag);
+                for (const item of nodeArray(node.a))if (0 === item) {
+                    if (++count > MAX_NODES) throw new TypeError('Public data tree exceeds its size limit');
+                } else visit(item, depth + 1);
+                return;
+            case 10:
+            case 11:
+                {
+                    exactFields(node, [
+                        't',
+                        'i',
+                        'p',
+                        'o'
+                    ]);
+                    if (!integer(node.o, 3)) throw new TypeError('Malformed public data object flags');
+                    declare(node.i, tag);
+                    const properties = pairs(node.p);
+                    if (properties.k.some((key)=>'string' != typeof key) || new Set(properties.k).size !== properties.k.length) throw new TypeError('Malformed or duplicate public data object keys');
+                    for (const item of properties.v)visit(item, depth + 1);
+                    return;
+                }
+            case 26:
+                exactFields(node, [
+                    't',
+                    'i',
+                    's'
+                ]);
+                if (!mapSentinel || 0 !== node.s) throw new TypeError('Unsupported public data special reference');
+                declare(node.i, tag);
+                return;
+            default:
+                throw new TypeError('Unsupported public data node');
+        }
+    };
+    visit(tree.t, 0);
+    if (metadata.some((id)=>!declarations.has(id))) throw new TypeError('Missing public data metadata reference');
+}
+export { validateSerializedData };

package/dist/esm/data/types.mjs

@@ -0,0 +1,6 @@
+const DATA_PROTOCOL_VERSION = 1;
+const DATA_CONTENT_TYPE = 'application/vnd.ultramodern.data+json';
+const DATA_STREAM_CONTENT_TYPE = 'application/vnd.ultramodern.data-stream+json';
+const LOADER_ID_PARAM = '__loader';
+const DIRECT_PARAM = '__ssrDirect';
+export { DATA_CONTENT_TYPE, DATA_PROTOCOL_VERSION, DATA_STREAM_CONTENT_TYPE, DIRECT_PARAM, LOADER_ID_PARAM };

package/dist/esm/document.mjs

@@ -0,0 +1,131 @@
+import { escapeInlineDataJSON } from "./data/codec.mjs";
+import { readRendererIdentity } from "./identity.mjs";
+function escapeAttribute(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
+}
+function validateAsset(asset) {
+    if (![
+        'stylesheet',
+        'modulepreload',
+        "script"
+    ].includes(asset.kind)) throw new TypeError('A document asset has an unknown kind.');
+    if ('string' != typeof asset.href || 0 === asset.href.length || asset.href.trim() !== asset.href || /[\u0000-\u0020\u007f]/u.test(asset.href)) throw new TypeError('A document asset requires a nonempty URL without whitespace or control characters.');
+    const url = new URL(asset.href, 'https://ultramodern.invalid/');
+    if ('http:' !== url.protocol && 'https:' !== url.protocol) throw new TypeError('A document asset must use an HTTP URL or relative URL.');
+    if (void 0 !== asset.crossOrigin && 'anonymous' !== asset.crossOrigin && 'use-credentials' !== asset.crossOrigin) throw new TypeError('A document asset has an unknown crossOrigin value.');
+    if (void 0 !== asset.scriptType && ("script" !== asset.kind || ![
+        'module',
+        'classic'
+    ].includes(asset.scriptType))) throw new TypeError("Only a script asset can declare module or classic scriptType.");
+}
+function collectDocumentAssets(assets) {
+    const collected = new Map();
+    for (const asset of assets){
+        validateAsset(asset);
+        const key = JSON.stringify([
+            asset.kind,
+            asset.href
+        ]);
+        const existing = collected.get(key);
+        if (existing) {
+            if (existing.integrity !== asset.integrity || existing.crossOrigin !== asset.crossOrigin || (existing.scriptType ?? 'module') !== (asset.scriptType ?? 'module')) throw new Error(`Conflicting document asset metadata for ${asset.href}.`);
+            continue;
+        }
+        collected.set(key, Object.freeze({
+            ...asset
+        }));
+    }
+    return Object.freeze([
+        ...collected.values()
+    ]);
+}
+function nonceAttribute(nonce) {
+    if (void 0 === nonce) return '';
+    if ('string' != typeof nonce || 0 === nonce.length) throw new TypeError('A document nonce must be a nonempty string.');
+    return ` nonce="${escapeAttribute(nonce)}"`;
+}
+function serializeDocumentAsset(asset, nonce, options = {}) {
+    validateAsset(asset);
+    if (void 0 !== options.async && ("script" !== asset.kind || 'boolean' != typeof options.async)) throw new TypeError("Async scheduling is only available for a script asset.");
+    if (void 0 !== options.defer && ("script" !== asset.kind || 'boolean' != typeof options.defer)) throw new TypeError("Deferred scheduling is only available for a script asset.");
+    if (true === options.async && true === options.defer) throw new TypeError("A script asset cannot be both async and deferred.");
+    const url = escapeAttribute(asset.href);
+    const integrity = void 0 === asset.integrity ? '' : ` integrity="${escapeAttribute(asset.integrity)}"`;
+    const crossOrigin = void 0 === asset.crossOrigin ? '' : ` crossorigin="${asset.crossOrigin}"`;
+    const attributes = `${integrity}${crossOrigin}${nonceAttribute(nonce)}`;
+    if ("script" === asset.kind) {
+        const scriptType = asset.scriptType ?? 'module';
+        const type = 'module' === scriptType ? ' type="module"' : '';
+        const scheduling = options.async ? ' async' : true === options.defer || 'classic' === scriptType && false !== options.defer ? ' defer' : '';
+        return `<script${type}${scheduling} src="${url}"${attributes}></script>`;
+    }
+    return `<link rel="${asset.kind}" href="${url}"${attributes}>`;
+}
+function serializeInlineData(input) {
+    if ('string' != typeof input.id || 0 === input.id.length) throw new TypeError('An inline data element requires a nonempty id.');
+    const payload = escapeInlineDataJSON(input.payload);
+    return `<script type="application/json" id="${escapeAttribute(input.id)}"${nonceAttribute(input.nonce)}>${payload}</script>`;
+}
+const RENDERER_BOOTSTRAP_ID = '__ULTRAMODERN_RENDERER__';
+function documentAttribute(value, name) {
+    if ('string' != typeof value || !value.trim()) throw new TypeError(`A native document requires a nonempty ${name}.`);
+    return escapeAttribute(value);
+}
+function prepareDocument(bootstrap, options = {}) {
+    if ('string' != typeof bootstrap.documentId || !bootstrap.documentId.trim()) throw new TypeError('A native document requires a nonempty document id.');
+    if ('boolean' != typeof bootstrap.hydrating) throw new TypeError('A native document must identify whether its root requires hydration.');
+    readRendererIdentity(bootstrap.identity, bootstrap.identity);
+    const rootId = options.rootId ?? 'root';
+    const root = documentAttribute(rootId, 'rootId');
+    const lang = documentAttribute(options.lang ?? 'en', 'lang');
+    if (rootId === RENDERER_BOOTSTRAP_ID) throw new TypeError('A document root cannot reuse the bootstrap id.');
+    const { script, style } = options.nonce ?? {};
+    const inlineIds = new Set();
+    const inlineData = (options.inlineData ?? []).map((item)=>{
+        if (item.id === RENDERER_BOOTSTRAP_ID || item.id === rootId) throw new TypeError('Document inline data cannot reuse the root or bootstrap id.');
+        if (inlineIds.has(item.id)) throw new TypeError(`Document inline data id ${item.id} is repeated.`);
+        inlineIds.add(item.id);
+        return serializeInlineData({
+            ...item,
+            nonce: script
+        });
+    });
+    const assets = collectDocumentAssets(options.assets ?? []);
+    return {
+        rootId: root,
+        lang,
+        headAssets: assets.filter((asset)=>"script" !== asset.kind).map((asset)=>serializeDocumentAsset(asset, 'stylesheet' === asset.kind ? style : script)).join(''),
+        bootstrap: serializeInlineData({
+            id: RENDERER_BOOTSTRAP_ID,
+            payload: JSON.stringify(bootstrap),
+            nonce: script
+        }) + inlineData.join(''),
+        entryScripts: assets.filter((asset)=>"script" === asset.kind).map((asset)=>serializeDocumentAsset(asset, script, bootstrap.hydrating ? 'classic' === asset.scriptType ? {
+                defer: false
+            } : {
+                async: true
+            } : {})).join('')
+    };
+}
+function readDocumentBootstrap(document, expectedIdentity, extraFields = []) {
+    const elements = document.querySelectorAll(`[id="${RENDERER_BOOTSTRAP_ID}"]`);
+    if (1 !== elements.length) throw new Error('A native document requires exactly one renderer bootstrap.');
+    const element = elements.item(0);
+    if (!element || 'SCRIPT' !== element.tagName || 'application/json' !== element.getAttribute('type')) throw new Error('The native document is missing its renderer bootstrap.');
+    const payload = JSON.parse(element.textContent ?? '');
+    if (!payload || 'object' != typeof payload || Array.isArray(payload) || Object.keys(payload).some((key)=>![
+            'identity',
+            'documentId',
+            'hydrating',
+            ...extraFields
+        ].includes(key))) throw new Error('The native renderer bootstrap is malformed.');
+    const fields = payload;
+    const identity = readRendererIdentity(fields.identity, expectedIdentity);
+    if ('string' != typeof fields.documentId || !fields.documentId.trim()) throw new Error('The native renderer bootstrap requires a document id.');
+    if ('boolean' != typeof fields.hydrating) throw new Error('The native renderer bootstrap must say whether its root hydrates.');
+    return Object.freeze({
+        ...fields,
+        identity
+    });
+}
+export { RENDERER_BOOTSTRAP_ID, collectDocumentAssets, prepareDocument, readDocumentBootstrap, serializeDocumentAsset, serializeInlineData };

package/dist/esm/entry-client.mjs

@@ -0,0 +1,104 @@
+import { createDataClient, invokeRouteData } from "./data/index.mjs";
+import { RENDERER_BOOTSTRAP_ID } from "./document.mjs";
+import { nativeI18nView } from "./localization.mjs";
+import { isRoutedApplication } from "./router.mjs";
+import { untilAborted } from "./abort.mjs";
+function isNativeEntryHot(value) {
+    return 'object' == typeof value && null !== value && 'dispose' in value && 'function' == typeof value.dispose;
+}
+function clientRouteLoader(application, identity) {
+    const serverDataRoutes = new Set(application.serverDataRoutes);
+    return async (route, input)=>{
+        const loader = application.dataModules[route.id]?.loader;
+        if (loader) return invokeRouteData(loader, input, {
+            production: 'production' === process.env.NODE_ENV
+        });
+        if (!serverDataRoutes.has(route.id)) return {
+            kind: 'success',
+            value: void 0,
+            status: 200
+        };
+        return createDataClient(route.id, identity).loader({
+            request: input.request
+        });
+    };
+}
+function startNativeClientEntry(options, adapter) {
+    const identity = Object.freeze({
+        ...options.identity
+    });
+    const root = document.getElementById(options.rootId ?? 'root');
+    if (!root) throw new Error('The native application mount element is missing');
+    const bootstrap = document.getElementById(RENDERER_BOOTSTRAP_ID) ? adapter.readBootstrap(document, identity) : void 0;
+    const hydrating = bootstrap?.hydrating ?? false;
+    const controller = new AbortController();
+    const { signal } = controller;
+    let disposed = false;
+    let dispose;
+    if (isNativeEntryHot(options.hot)) options.hot.dispose(()=>{
+        disposed = true;
+        controller.abort(new DOMException('The application entry was disposed', 'AbortError'));
+        dispose?.();
+    });
+    const load = async ()=>{
+        const application = await untilAborted(options.load(), signal);
+        const { i18n } = options;
+        let instance;
+        if (i18n) {
+            const handoff = i18n.clientHandoff();
+            instance = await untilAborted(i18n.create(handoff.language, handoff.resources), signal);
+            const stopPersist = i18n.persist?.(instance);
+            if (stopPersist) signal.addEventListener('abort', stopPersist, {
+                once: true
+            });
+        }
+        const current = instance;
+        const localization = i18n && current ? {
+            i18n: nativeI18nView(i18n, current)
+        } : {};
+        if (!isRoutedApplication(application)) return {
+            kind: 'component',
+            component: application.default,
+            ...localization
+        };
+        const router = adapter.createRouter(application, {
+            identity,
+            loadRoute: clientRouteLoader(application, identity),
+            signal,
+            ...i18n && current ? {
+                rewrite: i18n.rewrite(()=>current.language)
+            } : {}
+        });
+        const stopSync = i18n && current ? i18n.syncWithRouter(router, current) : void 0;
+        if (stopSync) signal.addEventListener('abort', stopSync, {
+            once: true
+        });
+        try {
+            await untilAborted(adapter.prepareRouter(router, hydrating, signal), signal);
+        } catch (error) {
+            stopSync?.();
+            throw error;
+        }
+        return {
+            kind: 'router',
+            router,
+            ...localization
+        };
+    };
+    adapter.start({
+        root,
+        identity,
+        bootstrap,
+        signal,
+        load
+    }).then((release)=>{
+        dispose = release;
+        if (disposed) release();
+    }).catch((error)=>{
+        if (!signal.aborted) controller.abort(error);
+        if (!disposed) queueMicrotask(()=>{
+            throw error;
+        });
+    });
+}
+export { startNativeClientEntry };