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

package/dist/cjs/server.js

@@ -0,0 +1,224 @@
+"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__, {
+    renderOctaneApplication: ()=>renderOctaneApplication,
+    renderOctaneCSRDocument: ()=>renderOctaneCSRDocument
+});
+const document_namespaceObject = require("@modern-js/renderer-core/document");
+const session_namespaceObject = require("@modern-js/renderer-core/session");
+const server_namespaceObject = require("octane/server");
+const external_bootstrap_js_namespaceObject = require("./bootstrap.js");
+const external_federation_context_js_namespaceObject = require("./federation-context.js");
+function prepareOctaneDocument(session, document, hydrating) {
+    (0, external_bootstrap_js_namespaceObject.assertOctaneIdentity)(session.identity);
+    if ('node' !== session.platform.kind && 'worker' !== session.platform.kind) throw new Error('An Octane document requires a Node or worker request platform.');
+    (0, external_bootstrap_js_namespaceObject.assertNativeHydrationBuildId)(document.nativeHydrationBuildId);
+    const nonce = document.nonce;
+    return (0, document_namespaceObject.prepareDocument)({
+        identity: session.identity,
+        documentId: document.documentId,
+        hydrating,
+        nativeHydrationBuildId: document.nativeHydrationBuildId
+    }, {
+        rootId: document.rootId,
+        lang: document.lang,
+        nonce: {
+            script: nonce,
+            style: nonce
+        },
+        assets: document.assets,
+        inlineData: document.inlineData
+    });
+}
+async function resolveDocumentResponse(input) {
+    const { session } = input;
+    if (input.responsePolicy && input.resolveResponse) throw new Error('Choose one blocking Octane response policy resolver.');
+    if (input.resolveResponse) session.resolveResponse(await (0, session_namespaceObject.untilAborted)(input.resolveResponse(session), session.signal));
+    else if (input.responsePolicy) session.resolveResponse(input.responsePolicy);
+    else if (!session.responsePolicy) session.resolveResponse({
+        kind: 'document',
+        status: 200,
+        headers: [
+            [
+                'content-type',
+                'text/html; charset=utf-8'
+            ]
+        ],
+        cache: {
+            mode: 'no-store'
+        }
+    });
+}
+async function renderOctaneCSRDocument(input) {
+    const { session } = input;
+    try {
+        const { rootId, lang, bootstrap, headAssets, entryScripts } = prepareOctaneDocument(session, input.document, false);
+        await resolveDocumentResponse(input);
+        if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
+        session.startRendering();
+        const bytes = new TextEncoder().encode(`<!doctype html><html lang="${lang}"><head>${headAssets}</head><body><div id="${rootId}"></div>${bootstrap}${entryScripts}</body></html>`);
+        return session.respond(new ReadableStream({
+            start (controller) {
+                controller.enqueue(bytes);
+                controller.close();
+            }
+        }));
+    } catch (error) {
+        await session.fail(error);
+        throw error;
+    }
+}
+async function renderOctaneApplication(input) {
+    const { session, document } = input;
+    try {
+        const { rootId, lang, bootstrap, headAssets, entryScripts } = prepareOctaneDocument(session, document, true);
+        const earlyBootstrap = (0, server_namespaceObject.earlySignalBootstrapScript)(void 0 === document.nonce ? {} : {
+            nonce: document.nonce
+        });
+        await resolveDocumentResponse(input);
+        if (session.responsePolicy?.kind === 'terminal') return session.respond(null);
+        session.startRendering();
+        let head = '';
+        const federation = input.federation ? (0, external_federation_context_js_namespaceObject.createFederationScope)(input.federation, true, document.nonce) : void 0;
+        const App = federation ? ()=>(0, server_namespaceObject.createElement)(external_federation_context_js_namespaceObject.FederationRoot, {
+                scope: federation,
+                children: 'function' == typeof input.App ? (0, server_namespaceObject.createElement)(input.App, input.props) : input.App
+            }) : input.App;
+        const nativeStream = await (0, server_namespaceObject.renderToReadableStream)(App, input.props, {
+            signal: session.signal,
+            ...void 0 === document.nonce ? {} : {
+                nonce: document.nonce
+            },
+            earlySignalBootstrap: 'external',
+            ...void 0 === input.injection ? {} : {
+                injection: input.injection
+            },
+            streamedSignals: {
+                buildId: document.nativeHydrationBuildId,
+                documentId: document.documentId
+            },
+            headChannel: 'separate',
+            onHeadReady (value) {
+                head = value;
+            },
+            onError (error) {
+                if (session.signal.aborted) return;
+                session.markFallback();
+                console.error('Octane render error:', error);
+            }
+        });
+        const ready = nativeStream.allReady.then(()=>({
+                ok: true
+            }), (error)=>({
+                ok: false,
+                error
+            }));
+        const reader = nativeStream.getReader();
+        const encoder = new TextEncoder();
+        const prefix = encoder.encode(`<!doctype html><html lang="${lang}"><head>${head}${headAssets}</head><body>${earlyBootstrap}<div id="${rootId}">`);
+        const shellBootstrap = encoder.encode(`</div>${bootstrap}${entryScripts}`);
+        const suffix = encoder.encode('</body></html>');
+        let phase = 'prefix';
+        let released = false;
+        const release = ()=>{
+            if (released) return;
+            released = true;
+            reader.releaseLock();
+        };
+        let cancellation;
+        const cancelNative = (reason)=>{
+            if (cancellation) return cancellation;
+            if (released) return Promise.resolve();
+            cancellation = reader.cancel(reason).finally(release);
+            return cancellation;
+        };
+        const releaseNative = (reason)=>{
+            cancelNative(reason).catch(()=>{});
+        };
+        try {
+            session.registerCleanup(()=>releaseNative(session.signal.reason));
+        } catch (error) {
+            releaseNative(error);
+            throw error;
+        }
+        const body = new ReadableStream({
+            async pull (controller) {
+                try {
+                    if ('prefix' === phase) {
+                        phase = 'shell';
+                        controller.enqueue(prefix);
+                        return;
+                    }
+                    if ('bootstrap' === phase) {
+                        phase = 'native';
+                        controller.enqueue(shellBootstrap);
+                        return;
+                    }
+                    const next = await reader.read();
+                    if (!next.done) {
+                        if ('shell' === phase) phase = 'bootstrap';
+                        controller.enqueue(next.value);
+                        return;
+                    }
+                    if ('shell' === phase) throw new Error('Octane ended before publishing its initial shell.');
+                    const completion = await ready;
+                    release();
+                    if (!completion.ok) throw completion.error;
+                    phase = 'done';
+                    controller.enqueue(suffix);
+                    controller.close();
+                } catch (error) {
+                    phase = 'done';
+                    releaseNative(error);
+                    controller.error(error);
+                }
+            },
+            cancel (reason) {
+                phase = 'done';
+                releaseNative(reason);
+            }
+        }, {
+            highWaterMark: 0
+        });
+        return session.respond(body);
+    } catch (error) {
+        await session.fail(error);
+        throw error;
+    }
+}
+exports.renderOctaneApplication = __webpack_exports__.renderOctaneApplication;
+exports.renderOctaneCSRDocument = __webpack_exports__.renderOctaneCSRDocument;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "renderOctaneApplication",
+    "renderOctaneCSRDocument"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});