@bleedingdev/modern-js-renderer-octane 0.0.0-stage → 3.9.3-ultramodern.2

package/dist/cjs/router-client.js

@@ -0,0 +1,139 @@
+"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__, {
+    OctaneRouterRoot: ()=>OctaneRouterRoot,
+    prepareOctaneRouterHydration: ()=>prepareOctaneRouterHydration
+});
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const client_namespaceObject = require("@octanejs/tanstack-router/ssr/client");
+const external_octane_namespaceObject = require("octane");
+const external_router_snapshot_js_namespaceObject = require("./router-snapshot.js");
+const hydration = new WeakMap();
+function abortReason(signal) {
+    return void 0 === signal.reason ? new DOMException('Octane router hydration aborted', 'AbortError') : signal.reason;
+}
+function awaitHydration(promise, signal) {
+    if (!signal) return promise;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (success, error)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (success) resolve();
+            else reject(error);
+        };
+        const onAbort = ()=>finish(false, abortReason(signal));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        promise.then(()=>finish(true), (error)=>finish(false, error));
+        if (signal.aborted) onAbort();
+    });
+}
+function isReactiveMatchIds(value) {
+    return 'object' == typeof value && null !== value && 'function' == typeof Reflect.get(value, 'get') && 'function' == typeof Reflect.get(value, 'subscribe');
+}
+function waitForCommittedMatches(router, signal) {
+    signal?.throwIfAborted();
+    const matchesId = router.stores.matchesId;
+    if (matchesId.get().length > 0) return Promise.resolve();
+    if (!isReactiveMatchIds(matchesId)) throw new Error('Octane router hydration requires its native reactive match store');
+    return new Promise((resolve, reject)=>{
+        let subscription;
+        let settled = false;
+        const cleanup = ()=>{
+            subscription?.unsubscribe();
+            signal?.removeEventListener('abort', onAbort);
+        };
+        const finish = ()=>{
+            if (settled || 0 === matchesId.get().length) return;
+            settled = true;
+            cleanup();
+            resolve();
+        };
+        const onAbort = ()=>{
+            if (settled) return;
+            settled = true;
+            cleanup();
+            if (signal) reject(abortReason(signal));
+        };
+        signal?.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (signal?.aborted) return void onAbort();
+        subscription = matchesId.subscribe(finish);
+        if (settled) subscription.unsubscribe();
+        else finish();
+    });
+}
+async function prepareOctaneRouterHydration(router, options = {}) {
+    (0, external_octane_namespaceObject.initializeHydrationEventCapture)();
+    options.signal?.throwIfAborted();
+    const adapters = router.options.serializationAdapters ?? [];
+    if (!adapters.includes(external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter)) {
+        const nativeOptions = {
+            ...router.options,
+            serializationAdapters: [
+                external_router_snapshot_js_namespaceObject.octaneRouterSnapshotAdapter,
+                ...adapters
+            ]
+        };
+        router.update(nativeOptions);
+    }
+    let pending = hydration.get(router);
+    if (!pending) {
+        pending = Promise.resolve((0, client_namespaceObject.hydrate)(router)).then(()=>{});
+        pending.catch(()=>{});
+        hydration.set(router, pending);
+    }
+    await awaitHydration(pending, options.signal);
+    await waitForCommittedMatches(router, options.signal);
+    options.signal?.throwIfAborted();
+}
+const routerHydrationEffectSlot = Symbol((0, external_octane_namespaceObject.hookSlots)(1));
+function OctaneRouterRoot({ router }) {
+    (0, external_octane_namespaceObject.useEffect)(()=>{
+        window.$_TSR?.h();
+    }, [], routerHydrationEffectSlot);
+    return (0, external_octane_namespaceObject.createElement)(tanstack_router_namespaceObject.RouterProvider, {
+        router
+    });
+}
+exports.OctaneRouterRoot = __webpack_exports__.OctaneRouterRoot;
+exports.prepareOctaneRouterHydration = __webpack_exports__.prepareOctaneRouterHydration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OctaneRouterRoot",
+    "prepareOctaneRouterHydration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-handler.js

@@ -0,0 +1,168 @@
+"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__, {
+    createOctaneRequestHandler: ()=>createOctaneRequestHandler
+});
+const tanstack_router_namespaceObject = require("@octanejs/tanstack-router");
+const server_namespaceObject = require("@octanejs/tanstack-router/ssr/server");
+const external_router_server_cleanup_js_namespaceObject = require("./router-server-cleanup.js");
+const external_router_server_snapshot_js_namespaceObject = require("./router-server-snapshot.js");
+function withAbort(pending, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const finish = (success, value)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            if (success) resolve(value);
+            else reject(value);
+        };
+        const onAbort = ()=>finish(false, signal.reason);
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        pending.then((value)=>finish(true, value), (error)=>finish(false, error));
+        if (signal.aborted) onAbort();
+    });
+}
+const CSP_HEADERS = new Set([
+    'content-security-policy',
+    'content-security-policy-report-only',
+    'link',
+    'server-timing'
+]);
+function appendHeaders(destination, value) {
+    if (null == value) return;
+    const source = value instanceof Headers ? value : new Headers(value);
+    for (const [key, item] of Headers.prototype.entries.call(source))if ('set-cookie' !== key) if (CSP_HEADERS.has(key)) destination.append(key, item);
+    else if ('vary' === key) {
+        const fields = new Map();
+        for (const field of `${destination.get('vary') ?? ''},${item}`.split(',')){
+            const name = field.trim();
+            if (name && !fields.has(name.toLowerCase())) fields.set(name.toLowerCase(), name);
+        }
+        destination.set('vary', [
+            ...fields.values()
+        ].join(', '));
+    } else destination.set(key, item);
+    for (const cookie of Headers.prototype.getSetCookie.call(source))destination.append('set-cookie', cookie);
+}
+function requestHeaders(router) {
+    const headers = new Headers({
+        'content-type': 'text/html; charset=utf-8'
+    });
+    for (const match of router.stores.matches.get()){
+        const field = Object.getOwnPropertyDescriptor(match, 'headers');
+        if (field?.get || field?.set) throw new TypeError('Native Octane response headers must be owned values');
+        appendHeaders(headers, field?.value);
+    }
+    const redirect = router.stores.redirect.get();
+    if (redirect) appendHeaders(headers, redirect.headers);
+    return headers;
+}
+function createOctaneRequestHandler({ createRouter, request, session, getRouterManifest, serialization }) {
+    return async (callback)=>{
+        session.signal.throwIfAborted();
+        const router = createRouter();
+        let responseOwnsCleanup = false;
+        try {
+            const manifest = getRouterManifest ? await withAbort(Promise.resolve(getRouterManifest()), session.signal) : void 0;
+            (0, server_namespaceObject.attachRouterServerSsrUtils)({
+                router,
+                manifest
+            });
+            const guard = (0, external_router_server_snapshot_js_namespaceObject.prepareOctaneRouterSerialization)(router, session, {
+                ...serialization,
+                forbiddenValues: [
+                    request,
+                    ...serialization?.forbiddenValues ?? []
+                ]
+            });
+            session.registerCleanup(()=>router.cancelMatches());
+            const { url } = (0, server_namespaceObject.getNormalizedURL)(request.url, 'http://localhost');
+            const href = url.href.replace(url.origin, '');
+            router.update({
+                ...router.options,
+                history: (0, tanstack_router_namespaceObject.createMemoryHistory)({
+                    initialEntries: [
+                        href
+                    ]
+                }),
+                origin: router.options.origin ?? (0, server_namespaceObject.getOrigin)(request)
+            });
+            await withAbort(router.load(), session.signal);
+            guard.assertActive();
+            const redirect = router.stores.redirect.get();
+            if (redirect) {
+                const resolved = router.resolveRedirect(redirect);
+                const headers = requestHeaders(router);
+                return new Response(null, {
+                    status: resolved.status,
+                    statusText: resolved.statusText,
+                    headers
+                });
+            }
+            guard.assertMatches();
+            const serverSsr = router.serverSsr;
+            if (!serverSsr) throw new Error('Native Octane router SSR state is required');
+            await withAbort(serverSsr.dehydrate(), session.signal);
+            guard.assertActive();
+            const responseHeaders = requestHeaders(router);
+            const rendered = Promise.resolve(callback({
+                request,
+                router,
+                responseHeaders
+            }));
+            const result = (0, server_namespaceObject.normalizeSsrResponse)(await withAbort(rendered, session.signal).catch((error)=>{
+                if (session.signal.aborted) rendered.then((late)=>{
+                    try {
+                        (0, server_namespaceObject.normalizeSsrResponse)(late).response.body?.cancel().catch(()=>{});
+                    } catch  {}
+                }, ()=>{});
+                throw error;
+            }));
+            responseOwnsCleanup = 'stream' === result.serverSsrCleanup;
+            return result.response;
+        } catch (error) {
+            session.fail(error);
+            throw error;
+        } finally{
+            if (!responseOwnsCleanup) (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
+        }
+    };
+}
+exports.createOctaneRequestHandler = __webpack_exports__.createOctaneRequestHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOctaneRequestHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-injection.js

@@ -0,0 +1,139 @@
+"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__, {
+    createOctaneRouterInjection: ()=>createOctaneRouterInjection
+});
+const external_router_server_cleanup_js_namespaceObject = require("./router-server-cleanup.js");
+const SERIALIZATION_TIMEOUT_MS = 60000;
+function createOctaneRouterInjection(router, session, options = {}) {
+    const serverSsr = router.serverSsr;
+    if (!serverSsr) throw new Error('Native Octane router.serverSsr is required for streaming');
+    const timeoutMs = options.serializationTimeoutMs ?? SERIALIZATION_TIMEOUT_MS;
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > SERIALIZATION_TIMEOUT_MS) throw new TypeError('Octane router serialization timeout must be 1 to 60000 ms');
+    session.signal.throwIfAborted();
+    let settled = false;
+    let released = false;
+    let renderFinished = false;
+    let timer;
+    let stopSerialization;
+    const subscriptions = new Set();
+    let resolveDone;
+    let rejectDone;
+    const done = new Promise((resolve, reject)=>{
+        resolveDone = resolve;
+        rejectDone = reject;
+    });
+    done.catch(()=>{});
+    const settle = (error)=>{
+        if (settled) return;
+        settled = true;
+        if (void 0 !== timer) clearTimeout(timer);
+        timer = void 0;
+        stopSerialization?.();
+        stopSerialization = void 0;
+        if (void 0 === error) resolveDone();
+        else rejectDone(error);
+    };
+    const release = ()=>{
+        if (released) return;
+        released = true;
+        if (void 0 !== timer) clearTimeout(timer);
+        timer = void 0;
+        stopSerialization?.();
+        stopSerialization = void 0;
+        for (const unsubscribe of subscriptions)unsubscribe();
+        subscriptions.clear();
+        session.signal.removeEventListener('abort', onAbort);
+        if (!settled) settle(session.signal.reason ?? new Error('Octane router serialization was interrupted'));
+    };
+    function onAbort() {
+        settle(session.signal.reason ?? new DOMException('Octane request aborted', 'AbortError'));
+        release();
+    }
+    if (serverSsr.isSerializationFinished()) settle();
+    else stopSerialization = serverSsr.onSerializationFinished(()=>settle());
+    serverSsr.onCleanup(release);
+    session.signal.addEventListener('abort', onAbort, {
+        once: true
+    });
+    try {
+        session.registerCleanup(()=>{
+            release();
+            (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
+        });
+    } catch (error) {
+        release();
+        (0, external_router_server_cleanup_js_namespaceObject.cleanupOctaneRouterSSR)(router);
+        throw error;
+    }
+    return {
+        take () {
+            if (released) return '';
+            serverSsr.liftScriptBarrier();
+            return serverSsr.takeBufferedHtml() ?? '';
+        },
+        subscribe (notify) {
+            if (released) return ()=>{};
+            const stop = serverSsr.onInjectedHtml(notify);
+            let subscribed = true;
+            const unsubscribe = ()=>{
+                if (!subscribed) return;
+                subscribed = false;
+                subscriptions.delete(unsubscribe);
+                stop();
+            };
+            subscriptions.add(unsubscribe);
+            return unsubscribe;
+        },
+        done,
+        cancel (reason) {
+            settle(reason ?? new DOMException('Octane rendering cancelled', 'AbortError'));
+            release();
+            session.abort(reason);
+        },
+        renderComplete () {
+            if (released || renderFinished) return;
+            renderFinished = true;
+            serverSsr.setRenderFinished();
+            if (!serverSsr.isSerializationFinished() && !settled) timer = setTimeout(()=>{
+                const error = new Error('Octane router serialization timed out after app rendering');
+                settle(error);
+                session.fail(error);
+            }, timeoutMs);
+        }
+    };
+}
+exports.createOctaneRouterInjection = __webpack_exports__.createOctaneRouterInjection;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOctaneRouterInjection"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/router-server-cleanup.js

@@ -0,0 +1,46 @@
+"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__);
+const released = new WeakSet();
+function cleanupOctaneRouterSSR(router) {
+    const serverSsr = router.serverSsr;
+    if (!serverSsr || released.has(serverSsr)) return;
+    released.add(serverSsr);
+    serverSsr.cleanup();
+}
+__webpack_require__.d(__webpack_exports__, {
+    cleanupOctaneRouterSSR: ()=>cleanupOctaneRouterSSR
+});
+exports.cleanupOctaneRouterSSR = __webpack_exports__.cleanupOctaneRouterSSR;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cleanupOctaneRouterSSR"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});