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

package/dist/esm-node/entry-server.mjs

@@ -0,0 +1,216 @@
+import "node:module";
+import { untilAborted } from "./abort.mjs";
+import { handleDataRequest, invokeRouteData, normalizeDataResult } from "./data/index.mjs";
+import { assertRendererIdentity } from "./identity.mjs";
+import { nativeI18nView } from "./localization.mjs";
+import { isRoutedApplication, matchApplicationRouteIds, selectApplicationDataRoute } from "./router.mjs";
+function serverRouteLoader(application) {
+    return async (route, input)=>{
+        const loader = application.dataModules[route.id]?.loader;
+        if (!loader) return {
+            kind: 'success',
+            value: void 0,
+            status: 200
+        };
+        return invokeRouteData(loader, input, {
+            production: 'development' !== process.env.NODE_ENV
+        });
+    };
+}
+function resolveDocumentPolicy(session, vary) {
+    if (!session.responsePolicy) session.resolveResponse({
+        kind: 'document',
+        status: 200,
+        headers: [
+            [
+                'content-type',
+                'text/html; charset=utf-8'
+            ],
+            ...vary?.length ? [
+                [
+                    'vary',
+                    vary.join(', ')
+                ]
+            ] : []
+        ],
+        cache: {
+            mode: 'no-store'
+        }
+    });
+}
+const detectedVary = (language)=>language?.kind === 'language' ? language.vary : void 0;
+function createNativeServerEntry(options, adapter) {
+    const rendererIdentity = Object.freeze({
+        ...options.identity
+    });
+    const { i18n } = options;
+    const own = (request, context)=>{
+        assertRendererIdentity(context.entry, rendererIdentity);
+        assertRendererIdentity(context.session.identity, rendererIdentity);
+        if (request !== context.session.request) throw new Error('Native request/session ownership mismatch');
+    };
+    const prepare = (request, context)=>{
+        own(request, context);
+        return adapter.document({
+            documentId: crypto.randomUUID(),
+            rootId: options.rootId ?? 'root',
+            ...void 0 === context.nonce ? {} : {
+                nonce: context.nonce
+            },
+            ...void 0 === context.assets ? {} : {
+                assets: context.assets
+            }
+        }, context.nativeManifest, rendererIdentity);
+    };
+    const routedApplication = async (signal)=>{
+        const application = await untilAborted(options.app(), signal);
+        if (!isRoutedApplication(application)) throw new Error('unsupported-renderer-capability: ssrByRouteIds requires native route matching.');
+        return application;
+    };
+    const nativeCSRRequestHandler = (request, context)=>adapter.run(context.session, async ()=>{
+            const document = prepare(request, context);
+            if (!i18n) {
+                resolveDocumentPolicy(context.session);
+                return adapter.renderCSR(context, document);
+            }
+            const language = i18n.resolveRequest(request);
+            if ('redirect' === language.kind) return adapter.respond(context.session, i18n.redirect(language.location));
+            resolveDocumentPolicy(context.session, detectedVary(language));
+            return adapter.renderCSR(context, {
+                ...document,
+                lang: language.language,
+                inlineData: [
+                    i18n.handoff(language.language)
+                ]
+            });
+        });
+    const nativeMatchRouteIds = (request, context)=>adapter.run(context.session, async ()=>{
+            own(request, context);
+            const application = await routedApplication(context.session.signal);
+            const router = adapter.createRouter(application, {
+                identity: rendererIdentity,
+                loadRoute: serverRouteLoader(application),
+                request,
+                context: context.session.platform.bindings,
+                session: context.session,
+                ...i18n ? {
+                    rewrite: i18n.rewrite(()=>i18n.resolveRequest(request).language)
+                } : {}
+            });
+            return matchApplicationRouteIds(router, new URL(request.url));
+        });
+    const nativeRequestHandler = (request, context)=>adapter.run(context.session, async ()=>{
+            const document = prepare(request, context);
+            const { session } = context;
+            const application = await untilAborted(options.app(), session.signal);
+            const routed = isRoutedApplication(application);
+            const nativeRequest = routed ? new Request(request, {
+                signal: session.signal
+            }) : request;
+            const language = i18n?.resolveRequest(nativeRequest);
+            if (!routed && i18n && language?.kind === 'redirect') return adapter.respond(session, i18n.redirect(language.location));
+            const localize = async (inlineData = [])=>{
+                if (!i18n || !language) return {
+                    document,
+                    localization: void 0
+                };
+                const instance = await untilAborted(i18n.create(language.language), session.signal);
+                return {
+                    document: {
+                        ...document,
+                        lang: instance.language,
+                        inlineData: [
+                            ...inlineData,
+                            i18n.handoff(instance.language, instance)
+                        ]
+                    },
+                    localization: nativeI18nView(i18n, instance)
+                };
+            };
+            if (!routed) {
+                const localized = await localize(document.inlineData);
+                resolveDocumentPolicy(session, detectedVary(language));
+                return adapter.renderComponent(context, application.default, localized.document, localized.localization);
+            }
+            const bindings = session.platform.bindings;
+            const outcomes = [];
+            const outcomeRanks = [];
+            let routeOrder;
+            const addOutcome = (rank, outcome)=>{
+                const at = outcomeRanks.findIndex((other)=>other > rank);
+                const index = at < 0 ? outcomes.length : at;
+                outcomes.splice(index, 0, outcome);
+                outcomeRanks.splice(index, 0, rank);
+            };
+            const router = adapter.createRouter(application, {
+                identity: rendererIdentity,
+                loadRoute: serverRouteLoader(application),
+                request: nativeRequest,
+                context: bindings,
+                onOutcome: (routeId, outcome)=>{
+                    if ('response' in outcome) {
+                        routeOrder ??= matchApplicationRouteIds(router, new URL(nativeRequest.url));
+                        const rank = routeOrder.indexOf(routeId);
+                        addOutcome(rank < 0 ? 1 / 0 : rank, outcome);
+                    } else if (outcome.completion) {
+                        const completion = outcome.completion;
+                        completion.catch((error)=>session.fail(error));
+                        session.registerCleanup(()=>completion);
+                    }
+                },
+                session,
+                ...void 0 === context.nonce ? {} : {
+                    nonce: context.nonce
+                },
+                ...i18n && language ? {
+                    rewrite: i18n.rewrite(()=>language.language)
+                } : {}
+            });
+            const dataResponse = await handleDataRequest({
+                request: nativeRequest,
+                identity: rendererIdentity,
+                context: bindings,
+                privateValues: [
+                    context,
+                    session,
+                    session.platform,
+                    bindings
+                ],
+                production: 'development' !== process.env.NODE_ENV,
+                selectRoute: (dataRequest, routeId, operation)=>selectApplicationDataRoute(router, dataRequest, routeId, operation, application.dataModules)
+            });
+            if (dataResponse) return adapter.respond(session, dataResponse);
+            if (i18n && language?.kind === 'redirect') return adapter.respond(session, i18n.redirect(language.location));
+            const vary = detectedVary(language);
+            if (vary?.length) addOutcome(1 / 0, await normalizeDataResult(new Response(null, {
+                headers: {
+                    vary: vary.join(', ')
+                }
+            })));
+            const localized = await localize();
+            return adapter.renderRoutes({
+                request: nativeRequest,
+                context,
+                router,
+                outcomes,
+                document: localized.document,
+                forbiddenValues: [
+                    context,
+                    session,
+                    session.platform,
+                    bindings,
+                    nativeRequest
+                ],
+                ...localized.localization ? {
+                    i18n: localized.localization
+                } : {}
+            });
+        });
+    return {
+        rendererIdentity,
+        nativeRequestHandler,
+        nativeCSRRequestHandler,
+        nativeMatchRouteIds
+    };
+}
+export { createNativeServerEntry };

package/dist/esm-node/federation.mjs

@@ -0,0 +1,37 @@
+import "node:module";
+function getFederationHost(binding) {
+    if (void 0 === binding) return;
+    if ('function' != typeof binding?.instance) throw new TypeError('The native federation host binding is invalid.');
+    const instance = binding.instance();
+    if (!instance || 'function' != typeof instance.loadRemote) throw new TypeError('The application federation runtime has not started.');
+    return instance;
+}
+async function loadFederatedModule(instance, id) {
+    if (!instance) throw new Error(`Cannot load ${id}: this application has no Module Federation runtime. Add module-federation.config.ts with its remotes.`);
+    const module = await instance.loadRemote(id);
+    if (!module) throw new Error(`Remote module ${id} is unavailable`);
+    return module;
+}
+function remoteBrowserAssets(instance, id) {
+    const target = instance.remoteHandler?.idToRemoteMap?.[id];
+    const loaded = target && instance.moduleCache?.get(target.name);
+    const snapshot = loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
+    if (!snapshot || 'string' != typeof snapshot.publicPath || !snapshot.publicPath || 'string' != typeof snapshot.remoteEntry || !snapshot.remoteEntry) return;
+    const expose = snapshot.modules?.find((module)=>module.modulePath === target.expose);
+    if (!expose?.assets) return;
+    const publicPath = snapshot.publicPath;
+    const url = (file)=>/^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;
+    return {
+        js: [
+            url(snapshot.remoteEntry),
+            ...(expose.assets.js?.sync ?? []).map(url)
+        ],
+        css: [
+            ...new Set([
+                ...expose.assets.css?.sync ?? [],
+                ...expose.assets.css?.async ?? []
+            ].map(url))
+        ]
+    };
+}
+export { getFederationHost, loadFederatedModule, remoteBrowserAssets };

package/dist/esm-node/identity.mjs

@@ -0,0 +1,64 @@
+import "node:module";
+function resolveRenderer(value = 'react') {
+    if ('string' == typeof value && value.trim() === value && /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(value)) return value;
+    throw new Error(`Unsupported UltraModern renderer: ${String(value)}`);
+}
+function identityCacheKey(identity) {
+    resolveRenderer(identity.renderer);
+    for (const key of [
+        'appId',
+        'entryName',
+        'buildId'
+    ])if ('string' != typeof identity[key] || 0 === identity[key].trim().length) throw new Error(`Renderer identity requires a nonempty ${key}`);
+    if (1 !== identity.protocolVersion) throw new Error('Unsupported renderer data protocol version');
+    return JSON.stringify([
+        identity.renderer,
+        identity.appId,
+        identity.entryName,
+        identity.protocolVersion,
+        identity.buildId
+    ]);
+}
+function assertRendererIdentity(actual, expected) {
+    if (identityCacheKey(actual) !== identityCacheKey(expected)) throw new Error('Renderer identity conflicts with the application build');
+}
+const IDENTITY_FIELDS = [
+    'renderer',
+    'appId',
+    'entryName',
+    'protocolVersion',
+    'buildId'
+];
+function readRendererIdentity(value, expected) {
+    if (!value || 'object' != typeof value || ![
+        Object.prototype,
+        null
+    ].includes(Object.getPrototypeOf(value)) || Object.keys(value).some((key)=>!IDENTITY_FIELDS.includes(key))) throw new Error('A renderer identity must contain only identity fields.');
+    const identity = value;
+    assertRendererIdentity(identity, expected);
+    return Object.freeze({
+        renderer: identity.renderer,
+        appId: identity.appId,
+        entryName: identity.entryName,
+        protocolVersion: identity.protocolVersion,
+        buildId: identity.buildId
+    });
+}
+function nativeModuleManifestFilename(renderer, entryName) {
+    if ('string' != typeof entryName || !entryName.trim()) throw new Error('Native module manifests require an application entry name.');
+    return `${resolveRenderer(renderer)}-module-manifest.${encodeURIComponent(entryName)}.json`;
+}
+const RENDERER_IDENTITY_HEADER = 'x-ultramodern-renderer-identity';
+function serializeRendererIdentityHeader(identity) {
+    identityCacheKey(identity);
+    return JSON.stringify({
+        renderer: identity.renderer,
+        appId: identity.appId,
+        entryName: identity.entryName,
+        protocolVersion: identity.protocolVersion,
+        buildId: identity.buildId
+    }).replace(/[\u007f-\u{10ffff}]/gu, (character)=>Array.from({
+            length: character.length
+        }, (_, index)=>`\\u${character.charCodeAt(index).toString(16).padStart(4, '0')}`).join(''));
+}
+export { RENDERER_IDENTITY_HEADER, assertRendererIdentity, identityCacheKey, nativeModuleManifestFilename, readRendererIdentity, resolveRenderer, serializeRendererIdentityHeader };

package/dist/esm-node/index.mjs

@@ -0,0 +1,2 @@
+import "node:module";
+export { assertRendererIdentity, identityCacheKey, resolveRenderer } from "./identity.mjs";

package/dist/esm-node/localization.mjs

@@ -0,0 +1,11 @@
+import "node:module";
+function nativeI18nView(i18n, instance) {
+    return {
+        instance,
+        languages: i18n.languages,
+        ...void 0 === i18n.localisedUrls ? {} : {
+            localisedUrls: i18n.localisedUrls
+        }
+    };
+}
+export { nativeI18nView };

package/dist/esm-node/router.mjs

@@ -0,0 +1,226 @@
+import "node:module";
+import { untilAborted } from "./abort.mjs";
+import { DataProtocolError, parsePublicData, serializePublicData, toTanstackPath } from "./data/index.mjs";
+class RouteDataError extends Error {
+    constructor(routeId, outcome){
+        super(outcome.error.message);
+        this.name = outcome.error.name;
+        this.routeId = routeId;
+        this.status = 'response' in outcome ? outcome.response.status : outcome.status;
+        this.data = outcome.data;
+    }
+}
+function resolveRouteData(native, routeId, outcome, project = (value)=>value) {
+    switch(outcome.kind){
+        case 'success':
+            return project(outcome.value);
+        case 'deferred':
+            {
+                const value = parsePublicData(serializePublicData(outcome.critical));
+                for (const [key, promise] of Object.entries(outcome.deferred))Object.defineProperty(value, key, {
+                    value: promise,
+                    enumerable: true,
+                    writable: true,
+                    configurable: true
+                });
+                return project(value);
+            }
+        case 'redirect':
+            throw native.redirect({
+                href: outcome.location,
+                ...'response' in outcome ? {
+                    headers: outcome.response.headers
+                } : {},
+                statusCode: 'response' in outcome ? outcome.response.status : outcome.status
+            });
+        case 'not-found':
+            throw native.notFound({
+                data: project(outcome.value)
+            });
+        case 'error':
+            {
+                const error = project(outcome.error);
+                if (!error || 'object' != typeof error || !('name' in error) || 'string' != typeof error.name || !('message' in error) || 'string' != typeof error.message) throw new DataProtocolError('Invalid public route error');
+                throw Object.freeze(new RouteDataError(routeId, {
+                    ...outcome,
+                    error: {
+                        name: error.name,
+                        message: error.message
+                    },
+                    data: project(outcome.data)
+                }));
+            }
+    }
+}
+function splitFileSystemRoutes(routes) {
+    const roots = routes.filter((route)=>route.isRoot);
+    if (roots.length > 1) throw new Error('A filesystem route tree requires one application root');
+    const root = roots[0];
+    const ids = new Set();
+    const visit = (route, nested)=>{
+        if (nested && route.isRoot) throw new Error('An application root cannot be a child route');
+        if (ids.has(route.id)) throw new Error(`Duplicate filesystem route id: ${route.id}`);
+        ids.add(route.id);
+        for (const child of route.children)visit(child, true);
+    };
+    for (const route of routes)visit(route, false);
+    return {
+        root,
+        children: root ? [
+            ...root.children,
+            ...routes.filter((route)=>route !== root)
+        ] : routes
+    };
+}
+function nativeRoutePath(route) {
+    const path = route.index ? '/' : route.path;
+    return path ? {
+        path: toTanstackPath(path)
+    } : {
+        id: route.id
+    };
+}
+async function loadFileSystemRoute(route, loadRoute, options, { params, location, abortController }) {
+    const base = options.request?.url ?? ("u" < typeof window ? void 0 : window.location.href);
+    if (!base) throw new Error('A server route loader requires its request');
+    const owners = [
+        abortController.signal,
+        ...options.request ? [
+            options.request.signal
+        ] : [],
+        ...options.signal ? [
+            options.signal
+        ] : []
+    ];
+    const signal = owners.length > 1 ? AbortSignal.any(owners) : owners[0];
+    signal.throwIfAborted();
+    const request = new Request(new URL(location.publicHref, base), {
+        headers: options.request?.headers,
+        signal
+    });
+    const outcome = await untilAborted(loadRoute(route, {
+        request,
+        routeId: route.id,
+        params,
+        context: options.context
+    }), signal);
+    return {
+        outcome,
+        request,
+        signal
+    };
+}
+function matchApplicationRoutes(router, url) {
+    return router.matchRoutes(router.parseLocation({
+        href: url.pathname + url.search + url.hash,
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash,
+        state: {
+            __TSR_index: 0
+        }
+    }));
+}
+function applicationRouteId(router, nativeRouteId) {
+    const staticData = router.routesById[nativeRouteId]?.options.staticData;
+    const id = staticData && 'object' == typeof staticData ? Reflect.get(staticData, 'ultramodernRouteId') : void 0;
+    return 'string' == typeof id ? id : void 0;
+}
+function matchApplicationRouteIds(router, url) {
+    return matchApplicationRoutes(router, url).flatMap((match)=>{
+        const id = applicationRouteId(router, match.routeId);
+        return void 0 === id ? [] : [
+            id
+        ];
+    });
+}
+function selectApplicationDataRoute(router, request, requestedRouteId, operation, handlers) {
+    const match = matchApplicationRoutes(router, new URL(request.url)).find((candidate)=>applicationRouteId(router, candidate.routeId) === requestedRouteId);
+    const handler = handlers[requestedRouteId]?.[operation];
+    if (!match || 'function' != typeof handler) return;
+    return {
+        routeId: requestedRouteId,
+        params: match.params,
+        handler
+    };
+}
+function isRoutedApplication(application) {
+    return 'routeIR' in application;
+}
+const viewFields = [
+    'component',
+    'pendingComponent',
+    'errorComponent',
+    'notFoundComponent'
+];
+function resolveRouteSources(sources) {
+    const module = {};
+    for (const field of viewFields){
+        const source = sources[field];
+        if (source) module[field] = source.default;
+    }
+    if (sources.head) module.head = sources.head.head ?? sources.head.default;
+    if (sources.search) {
+        const validateSearch = sources.search.validateSearch ?? sources.search.default;
+        if ('function' != typeof validateSearch) throw new Error('A native search module must export validateSearch or a default validator');
+        module.validateSearch = validateSearch;
+    }
+    return module;
+}
+function createNativeRouter(application, options, factory) {
+    const context = options.context ?? {};
+    if (Object.hasOwn(context, 'ultramodern')) throw new Error('The native router context reserves ultramodern metadata');
+    const modules = Object.fromEntries(Object.entries(application.routeModules).map(([id, sources])=>[
+            id,
+            resolveRouteSources(sources)
+        ]));
+    let router;
+    const routeTree = factory.routeTree(application.routeIR, modules, {
+        ...options.request ? {
+            request: options.request
+        } : {},
+        ...options.signal ? {
+            signal: options.signal
+        } : {},
+        context,
+        ...options.onOutcome ? {
+            onOutcome: options.onOutcome
+        } : {},
+        ...options.session ? {
+            session: options.session
+        } : {},
+        getRouter: ()=>{
+            if (!router) throw new Error('The native router is not created yet');
+            return router;
+        },
+        loadRoute: options.loadRoute
+    });
+    const url = options.request ? new URL(options.request.url) : void 0;
+    router = factory.router({
+        routeTree,
+        basepath: application.basePath,
+        context: {
+            ultramodern: Object.freeze({
+                rendererIdentity: Object.freeze({
+                    ...options.identity
+                })
+            })
+        },
+        ...options.rewrite ? {
+            rewrite: options.rewrite
+        } : {},
+        ...void 0 === options.nonce ? {} : {
+            ssr: {
+                nonce: options.nonce
+            }
+        },
+        ...url ? {
+            location: {
+                origin: url.origin,
+                href: url.pathname + url.search + url.hash
+            }
+        } : {}
+    });
+    return router;
+}
+export { RouteDataError, createNativeRouter, isRoutedApplication, loadFileSystemRoute, matchApplicationRouteIds, matchApplicationRoutes, nativeRoutePath, resolveRouteData, selectApplicationDataRoute, splitFileSystemRoutes, untilAborted };

package/dist/esm-node/server/assets.mjs

@@ -0,0 +1,16 @@
+import "node:module";
+import { collectDocumentAssets } from "../document.mjs";
+import { assertRendererIdentity } from "../identity.mjs";
+const RENDERER_ASSET_MANIFEST_FILE = 'renderer-assets.json';
+function validateNativeClientAssetManifest(value, expectedIdentity) {
+    if (!value || 'object' != typeof value || Array.isArray(value)) throw new Error('Missing native client asset manifest. Rebuild the application before serving.');
+    const manifest = value;
+    if ('ultramodern-renderer-assets' !== manifest.schema || 1 !== manifest.version || 'react' === expectedIdentity.renderer || manifest.renderer !== expectedIdentity.renderer) throw new Error('Native client asset manifest conflicts with the selected renderer or schema.');
+    const entry = manifest.entries?.[expectedIdentity.entryName];
+    if (!entry?.rendererIdentity || !Array.isArray(entry.assets)) throw new Error(`Native client asset manifest is missing entry ${expectedIdentity.entryName}.`);
+    assertRendererIdentity(entry.rendererIdentity, expectedIdentity);
+    const assets = collectDocumentAssets(entry.assets);
+    if (!assets.some((asset)=>"script" === asset.kind)) throw new Error(`Native client asset manifest has no application script for ${expectedIdentity.entryName}.`);
+    return assets;
+}
+export { RENDERER_ASSET_MANIFEST_FILE, validateNativeClientAssetManifest };