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

package/dist/cjs/router.js

@@ -0,0 +1,293 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RouteDataError: ()=>RouteDataError,
+    createNativeRouter: ()=>createNativeRouter,
+    isRoutedApplication: ()=>isRoutedApplication,
+    loadFileSystemRoute: ()=>loadFileSystemRoute,
+    matchApplicationRouteIds: ()=>matchApplicationRouteIds,
+    matchApplicationRoutes: ()=>matchApplicationRoutes,
+    nativeRoutePath: ()=>nativeRoutePath,
+    resolveRouteData: ()=>resolveRouteData,
+    selectApplicationDataRoute: ()=>selectApplicationDataRoute,
+    splitFileSystemRoutes: ()=>splitFileSystemRoutes,
+    untilAborted: ()=>external_abort_js_namespaceObject.untilAborted
+});
+const external_abort_js_namespaceObject = require("./abort.js");
+const index_js_namespaceObject = require("./data/index.js");
+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 = (0, index_js_namespaceObject.parsePublicData)((0, index_js_namespaceObject.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 index_js_namespaceObject.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: (0, index_js_namespaceObject.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 (0, external_abort_js_namespaceObject.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;
+}
+exports.RouteDataError = __webpack_exports__.RouteDataError;
+exports.createNativeRouter = __webpack_exports__.createNativeRouter;
+exports.isRoutedApplication = __webpack_exports__.isRoutedApplication;
+exports.loadFileSystemRoute = __webpack_exports__.loadFileSystemRoute;
+exports.matchApplicationRouteIds = __webpack_exports__.matchApplicationRouteIds;
+exports.matchApplicationRoutes = __webpack_exports__.matchApplicationRoutes;
+exports.nativeRoutePath = __webpack_exports__.nativeRoutePath;
+exports.resolveRouteData = __webpack_exports__.resolveRouteData;
+exports.selectApplicationDataRoute = __webpack_exports__.selectApplicationDataRoute;
+exports.splitFileSystemRoutes = __webpack_exports__.splitFileSystemRoutes;
+exports.untilAborted = __webpack_exports__.untilAborted;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RouteDataError",
+    "createNativeRouter",
+    "isRoutedApplication",
+    "loadFileSystemRoute",
+    "matchApplicationRouteIds",
+    "matchApplicationRoutes",
+    "nativeRoutePath",
+    "resolveRouteData",
+    "selectApplicationDataRoute",
+    "splitFileSystemRoutes",
+    "untilAborted"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/assets.js

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RENDERER_ASSET_MANIFEST_FILE: ()=>RENDERER_ASSET_MANIFEST_FILE,
+    validateNativeClientAssetManifest: ()=>validateNativeClientAssetManifest
+});
+const external_document_js_namespaceObject = require("../document.js");
+const external_identity_js_namespaceObject = require("../identity.js");
+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}.`);
+    (0, external_identity_js_namespaceObject.assertRendererIdentity)(entry.rendererIdentity, expectedIdentity);
+    const assets = (0, external_document_js_namespaceObject.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;
+}
+exports.RENDERER_ASSET_MANIFEST_FILE = __webpack_exports__.RENDERER_ASSET_MANIFEST_FILE;
+exports.validateNativeClientAssetManifest = __webpack_exports__.validateNativeClientAssetManifest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RENDERER_ASSET_MANIFEST_FILE",
+    "validateNativeClientAssetManifest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});