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

package/dist/cjs/worker-federation-contexts.js

@@ -0,0 +1,97 @@
+"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__, {
+    OCTANE_WORKER_CONTEXT_KEYS: ()=>OCTANE_WORKER_CONTEXT_KEYS,
+    getOctaneWorkerRouterRewrite: ()=>getOctaneWorkerRouterRewrite,
+    registerOctaneWorkerContext: ()=>registerOctaneWorkerContext,
+    registerOctaneWorkerRouterRewrite: ()=>registerOctaneWorkerRouterRewrite,
+    useOctaneWorkerContextKeys: ()=>useOctaneWorkerContextKeys
+});
+const external_octane_namespaceObject = require("octane");
+const OCTANE_WORKER_CONTEXT_KEYS = Object.freeze({
+    router: 'ultramodern.octane.router-context.v1',
+    match: 'ultramodern.octane.match-context.v1',
+    i18n: 'ultramodern.octane.i18n-context.v1'
+});
+const builtinKeys = Object.values(OCTANE_WORKER_CONTEXT_KEYS);
+const contexts = new Map();
+function registerOctaneWorkerContext(context, codec) {
+    const { key, isProvided } = codec;
+    if (!builtinKeys.includes(key) || 'function' != typeof isProvided) throw new TypeError('Invalid Octane Worker builtin context codec');
+    const unregister = (0, external_octane_namespaceObject.registerExternalSnapshotContext)(context, codec);
+    const hasProvider = ()=>isProvided((0, external_octane_namespaceObject.useContext)(context));
+    contexts.set(key, hasProvider);
+    return ()=>{
+        if (contexts.get(key) !== hasProvider) return;
+        unregister();
+        contexts.delete(key);
+    };
+}
+function useOctaneWorkerContextKeys(explicit = []) {
+    const selected = [];
+    for (const key of builtinKeys){
+        const hasProvider = contexts.get(key);
+        if (hasProvider?.() && !explicit.includes(key)) selected.push(key);
+    }
+    return [
+        ...selected,
+        ...explicit
+    ];
+}
+let routerRewrite;
+function registerOctaneWorkerRouterRewrite(codec) {
+    if (routerRewrite || 'function' != typeof codec.capture || 'function' != typeof codec.restore) throw new TypeError('Invalid or duplicate Octane Worker router rewrite codec');
+    const captured = Object.freeze({
+        capture: codec.capture,
+        restore: codec.restore
+    });
+    routerRewrite = captured;
+    return ()=>{
+        if (routerRewrite === captured) routerRewrite = void 0;
+    };
+}
+function getOctaneWorkerRouterRewrite() {
+    return routerRewrite;
+}
+exports.OCTANE_WORKER_CONTEXT_KEYS = __webpack_exports__.OCTANE_WORKER_CONTEXT_KEYS;
+exports.getOctaneWorkerRouterRewrite = __webpack_exports__.getOctaneWorkerRouterRewrite;
+exports.registerOctaneWorkerContext = __webpack_exports__.registerOctaneWorkerContext;
+exports.registerOctaneWorkerRouterRewrite = __webpack_exports__.registerOctaneWorkerRouterRewrite;
+exports.useOctaneWorkerContextKeys = __webpack_exports__.useOctaneWorkerContextKeys;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "OCTANE_WORKER_CONTEXT_KEYS",
+    "getOctaneWorkerRouterRewrite",
+    "registerOctaneWorkerContext",
+    "registerOctaneWorkerRouterRewrite",
+    "useOctaneWorkerContextKeys"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/worker-federation.js

@@ -0,0 +1,97 @@
+"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__, {
+    createNativeWorkerFederationRuntime: ()=>createNativeWorkerFederationRuntime
+});
+const worker_federation_namespaceObject = require("@modern-js/renderer-core/worker-federation");
+const server_namespaceObject = require("octane/server");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+const external_worker_federation_context_js_namespaceObject = require("./worker-federation-context.js");
+function isNativeWorkerComponent(value) {
+    return 'function' == typeof value;
+}
+function createNativeWorkerFederationRuntime(options, compiler) {
+    const { resources } = options;
+    const bindings = options.bindings;
+    const transport = resources.workerFederationServices?.length ? (0, worker_federation_namespaceObject.createWorkerFederationTransport)({
+        admitRendererContract: compiler.admitRendererContract,
+        services: resources.workerFederationServices.map((service)=>{
+            const binding = bindings && Reflect.get(bindings, service.binding);
+            if (!binding || 'object' != typeof binding && 'function' != typeof binding || !('fetch' in binding) || 'function' != typeof binding.fetch) throw new Error(`Native Worker federation requires service binding ${service.binding}.`);
+            return {
+                ...service,
+                fetch: binding.fetch.bind(binding)
+            };
+        })
+    }) : void 0;
+    let handle;
+    if (resources.workerFederation) {
+        if (!compiler.registry || !resources.workerFederationManifestUrl) throw new Error('Native Worker federation requires its compiled expose registry and pinned manifest URL.');
+        handle = compiler.registry.initialize({
+            publication: resources.workerFederation.worker,
+            manifestUrl: resources.workerFederationManifestUrl,
+            admitRendererContract: compiler.admitRendererContract,
+            admitNativeRequest (payload, { admitted, signal }) {
+                const initializeContexts = transport ? (provide, request)=>{
+                    provide(external_federation_context_js_namespaceObject.FederationContext, (0, external_federation_context_js_namespaceObject.createFederationScope)(void 0, true, request.nonce));
+                    provide(external_worker_federation_context_js_namespaceObject.WorkerFederationContext, {
+                        transport,
+                        locale: admitted.locale,
+                        signal
+                    });
+                } : void 0;
+                return (0, server_namespaceObject.prepareExternalSnapshotRequest)(payload, {
+                    authority: admitted.coordinate.native,
+                    signal,
+                    ...initializeContexts ? {
+                        initializeContexts
+                    } : {}
+                });
+            },
+            releaseNativeRequest: server_namespaceObject.releasePreparedExternalSnapshotRequest,
+            async renderNativeSnapshot (module, request, { admitted }) {
+                const component = module && 'object' == typeof module && 'default' in module ? module.default : void 0;
+                if (!isNativeWorkerComponent(component)) throw new TypeError(`Native Worker expose ${admitted.expose} requires a default Octane component.`);
+                return (0, server_namespaceObject.serializeExternalSnapshot)(await (0, server_namespaceObject.renderExternalSnapshot)(component, request));
+            }
+        });
+    }
+    return {
+        transport,
+        handleRequest: handle ?? (()=>Promise.resolve(void 0))
+    };
+}
+exports.createNativeWorkerFederationRuntime = __webpack_exports__.createNativeWorkerFederationRuntime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeWorkerFederationRuntime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/bootstrap.mjs

@@ -0,0 +1,24 @@
+import { readDocumentBootstrap } from "@modern-js/renderer-core/document";
+import { readRendererIdentity } from "@modern-js/renderer-core/identity";
+function assertNativeHydrationBuildId(value) {
+    if ('string' != typeof value || 0 === value.trim().length) throw new Error('An Octane document requires its native client compilation identity.');
+}
+function assertOctaneIdentity(identity) {
+    readRendererIdentity(identity, identity);
+    if ('octane' !== identity.renderer) throw new Error('An Octane application requires an Octane renderer identity.');
+}
+function readOctaneDocumentBootstrap(document, expectedIdentity, expectedNativeHydrationBuildId) {
+    assertOctaneIdentity(expectedIdentity);
+    const { identity, documentId, hydrating, nativeHydrationBuildId } = readDocumentBootstrap(document, expectedIdentity, [
+        'nativeHydrationBuildId'
+    ]);
+    assertNativeHydrationBuildId(nativeHydrationBuildId);
+    if (void 0 !== expectedNativeHydrationBuildId && nativeHydrationBuildId !== expectedNativeHydrationBuildId) throw new Error('Octane hydration bytes belong to a different native client compilation.');
+    return Object.freeze({
+        identity,
+        documentId,
+        hydrating,
+        nativeHydrationBuildId
+    });
+}
+export { assertNativeHydrationBuildId, assertOctaneIdentity, readOctaneDocumentBootstrap };

package/dist/esm/client.mjs

@@ -0,0 +1,377 @@
+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";
+import { WorkerFederationApplication } from "./worker-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.workerFederation ? input.root.render(WorkerFederationApplication, {
+                    scope: input.workerFederation,
+                    federation: input.federation,
+                    application: next
+                }) : 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.retireWorkerFederation?.(),
+                ()=>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);
+    const workerController = input.workerFederation ? new AbortController() : void 0;
+    let workerFederation;
+    const retireWorkerFederation = ()=>cleanupResources([
+            ()=>workerController?.abort(new DOMException('The Worker federation document was disposed', 'AbortError')),
+            ()=>workerFederation?.transport.dispose()
+        ]);
+    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([
+            retireWorkerFederation,
+            ()=>root?.unmount(),
+            ()=>releaseModule?.(),
+            ()=>bridge?.dispose(),
+            release
+        ]);
+    };
+    try {
+        if (input.workerFederation && workerController) {
+            const signal = AbortSignal.any([
+                workerController.signal,
+                ...input.signal ? [
+                    input.signal
+                ] : []
+            ]);
+            const scope = 'function' == typeof input.workerFederation ? input.workerFederation(signal) : input.workerFederation;
+            workerFederation = {
+                ...scope,
+                signal: scope.signal ? AbortSignal.any([
+                    signal,
+                    scope.signal
+                ]) : signal
+            };
+        }
+        if (workerFederation && !hydration && !input.documentId) throw new Error('Worker federation requires the trusted document identity before application loading');
+        const federation = input.federation || workerFederation ? 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, workerFederation ? WorkerFederationApplication : federation ? FederationApplication : application.default, workerFederation ? {
+            scope: workerFederation,
+            federation,
+            application
+        } : federation ? {
+            scope: federation,
+            application
+        } : application.props, {
+            ...errors.options,
+            signalOwner: bridge.signalOwner,
+            externalSnapshots: {
+                documentId: hydration.documentId
+            }
+        });
+        else {
+            root = createRoot(input.container, {
+                ...errors.options,
+                ...input.documentId ? {
+                    externalSnapshots: {
+                        documentId: input.documentId
+                    }
+                } : {}
+            });
+            workerFederation ? root.render(WorkerFederationApplication, {
+                scope: workerFederation,
+                federation,
+                application
+            }) : 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,
+            workerFederation,
+            retireWorkerFederation,
+            ...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,44 @@
+import { createMemoryHistory, createRouter } from "@octanejs/tanstack-router";
+import { createElement } from "octane";
+import { I18nProvider } from "./i18n/I18nProvider.mjs";
+import { associateOctaneFileRouteSnapshot } from "./router-external-snapshot.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 })=>{
+        const router = createRouter({
+            ...options,
+            ...location ? {
+                origin: location.origin,
+                history: createMemoryHistory({
+                    initialEntries: [
+                        location.href
+                    ]
+                })
+            } : {}
+        });
+        associateOctaneFileRouteSnapshot(router);
+        return router;
+    }
+};
+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 };