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

package/dist/esm/client.mjs

@@ -0,0 +1,327 @@
+import { assertRendererIdentity } from "@modern-js/renderer-core/identity";
+import { createRoot, hydrateRoot } from "octane";
+import { bootstrapStreamedSignalHydration } from "octane/hydration/streamed-signals";
+import { assertNativeHydrationBuildId, assertOctaneIdentity, readOctaneDocumentBootstrap } from "./bootstrap.mjs";
+import { FederationApplication, createFederationScope } from "./federation-context.mjs";
+const roots = new WeakMap();
+const documents = new WeakMap();
+const moduleResources = new WeakMap();
+function claimModuleResources(application) {
+    const dispose = application.dispose;
+    if (!dispose) return ()=>{};
+    let resources = moduleResources.get(dispose);
+    if (resources?.retired) throw new Error('A retired Octane application requires a fresh module resource instance.');
+    if (!resources) {
+        resources = {
+            users: 0,
+            retired: false
+        };
+        moduleResources.set(dispose, resources);
+    }
+    resources.users++;
+    let released = false;
+    return ()=>{
+        if (released) return;
+        released = true;
+        resources.users--;
+        if (0 === resources.users && !resources.retired) {
+            resources.retired = true;
+            dispose();
+        }
+    };
+}
+function retireAbandonedModule(application) {
+    if (application.dispose && moduleResources.get(application.dispose)?.users) return;
+    if (application.dispose && moduleResources.get(application.dispose)?.retired) return;
+    claimModuleResources(application)();
+}
+function observeRootErrors(options) {
+    let failed = false;
+    let failure;
+    let handle;
+    return {
+        options: {
+            ...options,
+            onUncaughtError (error) {
+                if (failed) return;
+                failed = true;
+                failure = error;
+                if (handle) {
+                    const failedHandle = handle;
+                    queueMicrotask(()=>{
+                        try {
+                            failedHandle.dispose();
+                        } catch (cleanupError) {
+                            failure = new AggregateError([
+                                error,
+                                cleanupError
+                            ], 'Octane rendering and cleanup failed.');
+                        }
+                        if (options?.onUncaughtError) options.onUncaughtError(failure);
+                        else throw failure;
+                    });
+                }
+            }
+        },
+        attach (next) {
+            handle = next;
+        },
+        assertInitialRender () {
+            if (failed) {
+                options?.onUncaughtError?.(failure);
+                throw failure;
+            }
+        }
+    };
+}
+function claimRoot(container) {
+    if (9 === container.nodeType) throw new Error('An Octane application requires a subtree root in its framework-owned document.');
+    if (roots.has(container)) throw new Error('An Octane application already owns this root container.');
+    const owner = Symbol('Octane root owner');
+    roots.set(container, owner);
+    return ()=>{
+        if (roots.get(container) === owner) roots.delete(container);
+    };
+}
+function cleanupResources(cleanups) {
+    const errors = [];
+    for (const cleanup of cleanups)try {
+        cleanup();
+    } catch (error) {
+        errors.push(error);
+    }
+    if (errors.length) throw new AggregateError(errors, 'Octane application cleanup failed.');
+}
+function reportCleanupError(input, error) {
+    if (input.options?.onUncaughtError) input.options.onUncaughtError(error);
+    else queueMicrotask(()=>{
+        throw error;
+    });
+}
+function loadApplication(input, abandon) {
+    const acquire = (application)=>{
+        try {
+            validateModule(application);
+        } catch (error) {
+            if (application && 'function' == typeof application.dispose) retireAbandonedModule(application);
+            throw error;
+        }
+        return {
+            application,
+            releaseModule: claimModuleResources(application)
+        };
+    };
+    const { signal } = input;
+    if (!signal) return input.load().then(acquire);
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        let abandoned = false;
+        const onAbort = ()=>{
+            if (settled) return;
+            settled = true;
+            abandoned = true;
+            signal.removeEventListener('abort', onAbort);
+            try {
+                abandon();
+                reject(signal.reason);
+            } catch (cleanupError) {
+                reject(new AggregateError([
+                    signal.reason,
+                    cleanupError
+                ], 'Octane startup cancellation failed.'));
+            }
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        if (signal.aborted) return void onAbort();
+        let loading;
+        try {
+            loading = input.load();
+        } catch (error) {
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+            return;
+        }
+        loading.then((application)=>{
+            if (abandoned) return void queueMicrotask(()=>{
+                try {
+                    retireAbandonedModule(application);
+                } catch (error) {
+                    reportCleanupError(input, error);
+                }
+            });
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            try {
+                resolve(acquire(application));
+            } catch (error) {
+                reject(error);
+            }
+        }, (error)=>{
+            if (settled) return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+function validateModule(application) {
+    if (!application || 'function' != typeof application.default) throw new TypeError('An Octane application module must default-export a native component.');
+    if (void 0 !== application.dispose && 'function' != typeof application.dispose) throw new TypeError('An Octane application disposer must be a function.');
+}
+function createHandle(input) {
+    let releaseModule = input.releaseModule;
+    let disposed = false;
+    const handle = {
+        root: input.root,
+        identity: Object.freeze({
+            ...input.identity
+        }),
+        update (next) {
+            if (disposed) throw new Error('Cannot update a disposed Octane application.');
+            validateModule(next);
+            const previousRelease = releaseModule;
+            const nextRelease = claimModuleResources(next);
+            releaseModule = nextRelease;
+            try {
+                input.federation ? input.root.render(FederationApplication, {
+                    scope: input.federation,
+                    application: next
+                }) : input.root.render(next.default, next.props);
+                previousRelease();
+            } catch (error) {
+                cleanupResources([
+                    previousRelease,
+                    ()=>handle.dispose()
+                ]);
+                throw error;
+            }
+        },
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            input.signal?.removeEventListener('abort', onAbort);
+            cleanupResources([
+                ()=>input.root.unmount(),
+                ()=>releaseModule(),
+                ()=>input.bridge?.dispose(),
+                input.release
+            ]);
+        }
+    };
+    function onAbort() {
+        queueMicrotask(()=>{
+            try {
+                handle.dispose();
+            } catch (error) {
+                input.onCleanupError?.(error);
+            }
+        });
+    }
+    input.signal?.addEventListener('abort', onAbort, {
+        once: true
+    });
+    return handle;
+}
+async function startApplication(input, release, hydration) {
+    const errors = observeRootErrors(input.options);
+    let bridge;
+    let root;
+    let releaseModule;
+    let handle;
+    let cleaned = false;
+    const cleanup = ()=>{
+        if (handle) return void handle.dispose();
+        if (cleaned) return;
+        cleaned = true;
+        cleanupResources([
+            ()=>root?.unmount(),
+            ()=>releaseModule?.(),
+            ()=>bridge?.dispose(),
+            release
+        ]);
+    };
+    try {
+        const federation = input.federation ? createFederationScope(input.federation, false) : void 0;
+        if (hydration) {
+            const { document, documentId } = hydration;
+            bridge = bootstrapStreamedSignalHydration({
+                buildId: input.nativeHydrationBuildId,
+                documentId,
+                ...null === document.defaultView ? {} : {
+                    target: document.defaultView
+                }
+            });
+        }
+        const loaded = await loadApplication(input, cleanup);
+        const application = loaded.application;
+        releaseModule = loaded.releaseModule;
+        input.signal?.throwIfAborted();
+        if (bridge) root = hydrateRoot(input.container, federation ? FederationApplication : application.default, federation ? {
+            scope: federation,
+            application
+        } : application.props, {
+            ...errors.options,
+            signalOwner: bridge.signalOwner
+        });
+        else {
+            root = createRoot(input.container, errors.options);
+            federation ? root.render(FederationApplication, {
+                scope: federation,
+                application
+            }) : root.render(application.default, application.props);
+        }
+        errors.assertInitialRender();
+        input.signal?.throwIfAborted();
+        handle = createHandle({
+            root,
+            identity: input.identity,
+            releaseModule,
+            release,
+            bridge,
+            federation,
+            ...void 0 === input.signal ? {} : {
+                signal: input.signal
+            },
+            onCleanupError: (error)=>reportCleanupError(input, error)
+        });
+        errors.attach(handle);
+        return handle;
+    } catch (error) {
+        cleanup();
+        throw error;
+    }
+}
+async function mountOctaneApplication(input) {
+    assertOctaneIdentity(input.identity);
+    assertNativeHydrationBuildId(input.nativeHydrationBuildId);
+    input.signal?.throwIfAborted();
+    return startApplication(input, claimRoot(input.container));
+}
+async function hydrateOctaneApplication(input) {
+    assertOctaneIdentity(input.identity);
+    assertNativeHydrationBuildId(input.nativeHydrationBuildId);
+    assertNativeHydrationBuildId(input.documentNativeHydrationBuildId);
+    if (input.nativeHydrationBuildId !== input.documentNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    assertRendererIdentity(input.documentIdentity, input.identity);
+    input.signal?.throwIfAborted();
+    if ('string' != typeof input.documentId || 0 === input.documentId.trim().length) throw new Error('Octane hydration requires a nonempty document identity.');
+    const document = input.container.ownerDocument;
+    if (!document) throw new Error('An Octane hydration root requires a document.');
+    if (document !== globalThis.document) throw new Error('Octane hydration requires a root in the active browser document.');
+    if (documents.has(document)) throw new Error('An Octane signal bridge already owns this document.');
+    const releaseRoot = claimRoot(input.container);
+    const documentOwner = Symbol(input.documentId);
+    documents.set(document, documentOwner);
+    const release = ()=>{
+        releaseRoot();
+        if (documents.get(document) === documentOwner) documents.delete(document);
+    };
+    return startApplication(input, release, {
+        document,
+        documentId: input.documentId
+    });
+}
+export { hydrateOctaneApplication, mountOctaneApplication, readOctaneDocumentBootstrap };

package/dist/esm/entry-application.mjs

@@ -0,0 +1,39 @@
+import { createMemoryHistory, createRouter } from "@octanejs/tanstack-router";
+import { createElement } from "octane";
+import { I18nProvider } from "./i18n/I18nProvider.mjs";
+import { createFileSystemRouteTree } from "./routes.mjs";
+function componentView(component, i18n) {
+    const App = component;
+    if (!i18n) return App;
+    return ()=>createElement(I18nProvider, {
+            instance: i18n.instance,
+            languages: i18n.languages,
+            localisedUrls: i18n.localisedUrls,
+            children: createElement(App)
+        });
+}
+const octaneRouterFactory = {
+    routeTree: (routes, modules, options)=>createFileSystemRouteTree(routes, modules, options),
+    router: ({ location, ...options })=>createRouter({
+            ...options,
+            ...location ? {
+                origin: location.origin,
+                history: createMemoryHistory({
+                    initialEntries: [
+                        location.href
+                    ]
+                })
+            } : {}
+        })
+};
+function localizedRouterRoot(Root) {
+    return ({ router, i18n })=>createElement(I18nProvider, {
+            instance: i18n.instance,
+            languages: i18n.languages,
+            localisedUrls: i18n.localisedUrls,
+            children: createElement(Root, {
+                router
+            })
+        });
+}
+export { componentView, localizedRouterRoot, octaneRouterFactory };

package/dist/esm/entry-client.mjs

@@ -0,0 +1,54 @@
+import { startNativeClientEntry } from "@modern-js/renderer-core/entry-client";
+import { createNativeRouter } from "@modern-js/renderer-core/router";
+import { hydrateOctaneApplication, mountOctaneApplication, readOctaneDocumentBootstrap } from "./client.mjs";
+import { componentView, localizedRouterRoot, octaneRouterFactory } from "./entry-application.mjs";
+import { OctaneRouterRoot, prepareOctaneRouterHydration } from "./router-client.mjs";
+const LocalizedRouterRoot = localizedRouterRoot(OctaneRouterRoot);
+function startNativeClient(options) {
+    const { nativeHydrationBuildId } = options;
+    startNativeClientEntry(options, {
+        readBootstrap: (document, identity)=>readOctaneDocumentBootstrap(document, identity, nativeHydrationBuildId),
+        createRouter: (application, routerOptions)=>createNativeRouter(application, routerOptions, octaneRouterFactory),
+        async prepareRouter (router, hydrating, signal) {
+            if (hydrating) await prepareOctaneRouterHydration(router, {
+                signal
+            });
+            else await router.load();
+        },
+        async start ({ root, identity, bootstrap, signal, load }) {
+            const application = {
+                container: root,
+                identity,
+                nativeHydrationBuildId,
+                federation: options.federation,
+                signal,
+                load: async ()=>{
+                    const view = await load();
+                    if ('component' === view.kind) return {
+                        default: componentView(view.component, view.i18n)
+                    };
+                    return view.i18n ? {
+                        default: LocalizedRouterRoot,
+                        props: {
+                            router: view.router,
+                            i18n: view.i18n
+                        }
+                    } : {
+                        default: OctaneRouterRoot,
+                        props: {
+                            router: view.router
+                        }
+                    };
+                }
+            };
+            const handle = bootstrap?.hydrating ? await hydrateOctaneApplication({
+                ...application,
+                documentIdentity: bootstrap.identity,
+                documentId: bootstrap.documentId,
+                documentNativeHydrationBuildId: bootstrap.nativeHydrationBuildId
+            }) : await mountOctaneApplication(application);
+            return ()=>handle.dispose();
+        }
+    });
+}
+export { startNativeClient };

package/dist/esm/entry-server.mjs

@@ -0,0 +1,86 @@
+import { collectDataHeaders, dataMetadataToDocumentPolicy, mergeDataResponseIntoResponse, mergeDataResponseMetadata, mergeHeaderFields } from "@modern-js/renderer-core/data";
+import { createNativeServerEntry } from "@modern-js/renderer-core/entry-server";
+import { createNativeRouter } from "@modern-js/renderer-core/router";
+import { componentView, localizedRouterRoot, octaneRouterFactory } from "./entry-application.mjs";
+import { validateOctaneModuleManifest } from "./manifest.mjs";
+import { OctaneRouterServer, createOctaneRequestHandler, createOctaneRouterInjection, createSsrStreamResponse } from "./router-server.mjs";
+import { renderOctaneApplication, renderOctaneCSRDocument } from "./server.mjs";
+const OCTANE_DOCUMENT_FIELDS = new Set([
+    'content-language',
+    'content-location',
+    'content-disposition'
+]);
+function withOctaneDocumentFields(policy, responseHeaders) {
+    const fields = collectDataHeaders(responseHeaders).filter(([name])=>OCTANE_DOCUMENT_FIELDS.has(name.toLowerCase()));
+    return fields.length ? {
+        ...policy,
+        headers: [
+            ...policy.headers,
+            ...fields
+        ]
+    } : policy;
+}
+const LocalizedRouterServer = localizedRouterRoot(OctaneRouterServer);
+function entry_server_createNativeServerEntry(options) {
+    return createNativeServerEntry(options, {
+        document: (document, nativeManifest, identity)=>({
+                ...document,
+                nativeHydrationBuildId: validateOctaneModuleManifest(nativeManifest, identity).nativeHydrationBuildId
+            }),
+        run: (_session, callback)=>callback(),
+        respond: (_session, response)=>response,
+        createRouter: (application, routerOptions)=>createNativeRouter(application, routerOptions, octaneRouterFactory),
+        renderCSR: ({ session }, document)=>renderOctaneCSRDocument({
+                session,
+                document
+            }),
+        renderComponent: ({ session }, component, document, i18n)=>renderOctaneApplication({
+                session,
+                App: componentView(component, i18n),
+                document,
+                federation: options.federation
+            }),
+        async renderRoutes ({ request, context: { session }, router, outcomes, document, forbiddenValues, i18n }) {
+            const response = await createOctaneRequestHandler({
+                request,
+                session,
+                createRouter: ()=>router,
+                serialization: {
+                    forbiddenValues
+                }
+            })(async ({ router, responseHeaders })=>{
+                const metadata = mergeDataResponseMetadata(outcomes, {
+                    status: router.state.statusCode ?? 200
+                });
+                const policy = dataMetadataToDocumentPolicy({
+                    ...metadata,
+                    headers: mergeHeaderFields(collectDataHeaders(responseHeaders), metadata.headers)
+                });
+                session.resolveResponse(withOctaneDocumentFields(policy, responseHeaders));
+                const rendered = await renderOctaneApplication({
+                    session,
+                    ...i18n ? {
+                        App: LocalizedRouterServer,
+                        props: {
+                            router,
+                            i18n
+                        }
+                    } : {
+                        App: OctaneRouterServer,
+                        props: {
+                            router
+                        }
+                    },
+                    document,
+                    federation: options.federation,
+                    injection: createOctaneRouterInjection(router, session)
+                });
+                return createSsrStreamResponse(router, rendered);
+            });
+            return session.committedPolicy ? response : mergeDataResponseIntoResponse(response, mergeDataResponseMetadata(outcomes, {
+                status: response.status
+            }));
+        }
+    });
+}
+export { entry_server_createNativeServerEntry as createNativeServerEntry, withOctaneDocumentFields };

package/dist/esm/federation-context.mjs

@@ -0,0 +1,25 @@
+import { getFederationHost } from "@modern-js/renderer-core/federation";
+import { createContext, createElement } from "octane";
+const FederationContext = createContext(null);
+function createFederationScope(binding, server, nonce) {
+    return {
+        instance: getFederationHost(binding),
+        server,
+        ...void 0 === nonce ? {} : {
+            nonce
+        }
+    };
+}
+function FederationRoot(props) {
+    return createElement(FederationContext, {
+        value: props.scope,
+        children: props.children
+    });
+}
+function FederationApplication(props) {
+    return createElement(FederationRoot, {
+        scope: props.scope,
+        children: createElement(props.application.default, props.application.props)
+    });
+}
+export { FederationApplication, FederationContext, FederationRoot, createFederationScope };

package/dist/esm/federation.mjs

@@ -0,0 +1,65 @@
+import { loadFederatedModule, remoteBrowserAssets } from "@modern-js/renderer-core/federation";
+import { Suspense, createElement, lazy, preinit, useContext } from "octane";
+import { FederationContext } from "./federation-context.mjs";
+function withTimeout(promise, timeout, label) {
+    if (void 0 === timeout) return promise;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>reject(new Error(`Remote module ${label} did not load within ${timeout}ms`)), timeout);
+        timer.unref?.();
+        promise.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+function federatedComponent(remote, options = {}) {
+    if ('string' == typeof remote ? !/^[^/]+\/.+/u.test(remote) : 'function' != typeof remote) throw new TypeError("federatedComponent requires a remote id such as 'remote/Widget' or a loader");
+    if (void 0 !== options.timeout && (!Number.isFinite(options.timeout) || options.timeout <= 0)) throw new TypeError('federatedComponent timeout must be a positive number of milliseconds');
+    const id = 'string' == typeof remote ? remote : void 0;
+    const standalone = {
+        instance: void 0,
+        server: "u" < typeof document
+    };
+    const components = new WeakMap();
+    return (props)=>{
+        const context = useContext(FederationContext) ?? standalone;
+        let Remote = components.get(context);
+        if (!Remote) {
+            Remote = lazy(async ()=>{
+                try {
+                    if (context.server && !id) throw new Error('A federatedComponent loader renders in the browser only; use a remote id to server-render it');
+                    const module = await withTimeout(Promise.resolve().then(()=>id ? loadFederatedModule(context.instance, id) : remote()), options.timeout ?? (context.server ? 3000 : void 0), id ?? 'loader');
+                    if ('function' != typeof module?.default) throw new TypeError('A federated Octane module must default-export a native component');
+                    const assets = id && context.instance ? remoteBrowserAssets(context.instance, id) : void 0;
+                    if (context.server && !assets) throw new Error(`Cannot server-render ${id}: the host has no browser assets for this remote`);
+                    const component = module.default;
+                    const Loaded = (props)=>{
+                        for (const href of assets?.css ?? [])preinit(href, {
+                            as: 'style',
+                            precedence: 'federated',
+                            ...void 0 === context.nonce ? {} : {
+                                nonce: context.nonce
+                            }
+                        });
+                        return createElement(component, props);
+                    };
+                    return {
+                        default: Loaded
+                    };
+                } catch (error) {
+                    if (!context.server) components.delete(context);
+                    throw error;
+                }
+            });
+            components.set(context, Remote);
+        }
+        return createElement(Suspense, {
+            fallback: options.fallback,
+            children: createElement(Remote, props)
+        });
+    };
+}
+export { federatedComponent };

package/dist/esm/i18n/I18nProvider.mjs

@@ -0,0 +1,29 @@
+import { createElement, hookSlots, useEffect, useState } from "octane";
+import { I18nContext } from "./context.mjs";
+const languageStateSlot = Symbol(hookSlots(1));
+const languageSubscriptionSlot = Symbol(hookSlots(1));
+function I18nProvider(props) {
+    const [language, setLanguage] = useState(()=>props.instance.language, languageStateSlot);
+    useEffect(()=>{
+        const instance = props.instance;
+        setLanguage(instance.language);
+        const handleLanguageChanged = (lng)=>setLanguage(lng);
+        instance.on?.('languageChanged', handleLanguageChanged);
+        return ()=>{
+            instance.off?.('languageChanged', handleLanguageChanged);
+        };
+    }, [
+        props.instance
+    ], languageSubscriptionSlot);
+    const value = {
+        instance: props.instance,
+        languages: props.languages,
+        localisedUrls: props.localisedUrls,
+        language
+    };
+    return createElement(I18nContext, {
+        value,
+        children: props.children
+    });
+}
+export { I18nProvider };

package/dist/esm/i18n/LocalizedLink.mjs

@@ -0,0 +1,48 @@
+import { canonicalPath, configuredLanguage, localizePath } from "@modern-js/i18n-runtime-extensions/paths";
+import { createElement, hookSlots, useContext } from "octane";
+import { Link, useLocation, useRouter } from "../router.mjs";
+import { I18nContext } from "./context.mjs";
+const locationSlot = Symbol(hookSlots(1));
+function LocalizedLink(props) {
+    const context = useContext(I18nContext);
+    if (!context) throw new Error('[renderer-octane] LocalizedLink was used outside of an I18nProvider.');
+    const router = useRouter();
+    const language = void 0 === props.language ? context.language : configuredLanguage(props.language, context.languages);
+    const href = localizePath(props.to, language, {
+        languages: [
+            ...context.languages
+        ],
+        localisedUrls: context.localisedUrls
+    });
+    const crossLanguage = language !== context.language;
+    const rewrite = Boolean(router.options.rewrite);
+    return createElement(Link, {
+        to: rewrite ? props.to : href,
+        ...rewrite && crossLanguage ? {
+            mask: {
+                to: href
+            }
+        } : {},
+        ...crossLanguage ? {
+            hreflang: language
+        } : {},
+        class: props.class,
+        activeProps: props.activeProps,
+        inactiveProps: props.inactiveProps,
+        activeOptions: props.activeOptions,
+        replace: props.replace,
+        preload: props.preload
+    }, props.children);
+}
+function useIsLocalizedActive(canonicalTarget) {
+    const context = useContext(I18nContext);
+    if (!context) throw new Error('[renderer-octane] useIsLocalizedActive was used outside of an I18nProvider.');
+    const location = useLocation(void 0, locationSlot);
+    return canonicalPath(location.pathname, {
+        languages: [
+            ...context.languages
+        ],
+        localisedUrls: context.localisedUrls
+    }) === canonicalTarget;
+}
+export { LocalizedLink, useIsLocalizedActive };

package/dist/esm/i18n/context.mjs

@@ -0,0 +1,3 @@
+import { createContext } from "octane";
+const I18nContext = createContext(null);
+export { I18nContext };