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

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

@@ -0,0 +1,167 @@
+"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__);
+function checkWorkerFederationDeadline(deadlineAt, signal, controller) {
+    if (signal?.aborted) throw workerAbortReason(signal);
+    if (performance.now() >= deadlineAt) {
+        const error = new Error('Worker federation request deadline exceeded.');
+        controller?.abort(error);
+        throw error;
+    }
+}
+function workerFederationErrorMessage(error, fallback, maxLength = 1024) {
+    return error instanceof Error && error.message.length <= maxLength ? error.message : fallback;
+}
+function workerAbortReason(signal) {
+    return signal.reason ?? new DOMException('Worker federation request aborted.', 'AbortError');
+}
+function workerAbortable(operation, signal) {
+    if (signal.aborted) {
+        operation.catch(()=>void 0);
+        return Promise.reject(workerAbortReason(signal));
+    }
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>reject(workerAbortReason(signal));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        operation.then(resolve, reject).finally(()=>signal.removeEventListener('abort', onAbort));
+    });
+}
+async function readWorkerFederationJsonBody(body, signal, contentLength, checkDeadline) {
+    if (signal.aborted) {
+        body.cancel().catch(()=>void 0);
+        throw workerAbortReason(signal);
+    }
+    try {
+        checkDeadline?.();
+        if (null != contentLength) {
+            if (!/^\d+$/u.test(contentLength)) throw new Error('Worker federation body has an invalid Content-Length.');
+            if (Number(contentLength) > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+        }
+    } catch (error) {
+        body.cancel(error).catch(()=>void 0);
+        throw error;
+    }
+    const reader = body.getReader();
+    const onAbort = ()=>{
+        reader.cancel(workerAbortReason(signal)).catch(()=>void 0);
+    };
+    signal.addEventListener('abort', onAbort, {
+        once: true
+    });
+    try {
+        const chunks = [];
+        let length = 0;
+        while(true){
+            checkDeadline?.();
+            const chunk = await workerAbortable(reader.read(), signal);
+            checkDeadline?.();
+            if (chunk.done) break;
+            if (chunk.value.byteLength > WORKER_FEDERATION_MAX_BODY_BYTES - length) throw new WorkerFederationBodyTooLargeError();
+            chunks.push(new Uint8Array(chunk.value));
+            length += chunk.value.byteLength;
+        }
+        checkDeadline?.();
+        const bytes = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks){
+            bytes.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        if (signal.aborted) throw workerAbortReason(signal);
+        const decoded = new TextDecoder('utf-8', {
+            fatal: true
+        }).decode(bytes);
+        checkDeadline?.();
+        const result = JSON.parse(decoded);
+        checkDeadline?.();
+        return result;
+    } catch (error) {
+        reader.cancel(error).catch(()=>void 0);
+        throw error;
+    } finally{
+        signal.removeEventListener('abort', onAbort);
+        reader.releaseLock();
+    }
+}
+const WORKER_FEDERATION_MAX_BODY_BYTES = 8388608;
+class WorkerFederationBodyTooLargeError extends Error {
+    constructor(){
+        super('Worker federation body exceeds 8 MiB.');
+        this.name = 'WorkerFederationBodyTooLargeError';
+    }
+}
+function assertWorkerFederationBodySize(value) {
+    if (value.length > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+    let bytes = 0;
+    for(let index = 0; index < value.length; index++){
+        const code = value.charCodeAt(index);
+        if (code <= 0x7f) bytes++;
+        else if (code <= 0x7ff) bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && value.charCodeAt(index + 1) >= 0xdc00 && value.charCodeAt(index + 1) <= 0xdfff) {
+            bytes += 4;
+            index++;
+        } else bytes += 3;
+        if (bytes > WORKER_FEDERATION_MAX_BODY_BYTES) throw new WorkerFederationBodyTooLargeError();
+    }
+    return value;
+}
+__webpack_require__.d(__webpack_exports__, {
+    WorkerFederationBodyTooLargeError: ()=>WorkerFederationBodyTooLargeError,
+    assertWorkerFederationBodySize: ()=>assertWorkerFederationBodySize,
+    checkWorkerFederationDeadline: ()=>checkWorkerFederationDeadline,
+    readWorkerFederationJsonBody: ()=>readWorkerFederationJsonBody,
+    workerAbortReason: ()=>workerAbortReason,
+    workerAbortable: ()=>workerAbortable,
+    workerFederationErrorMessage: ()=>workerFederationErrorMessage
+}, {
+    WORKER_FEDERATION_MAX_BODY_BYTES: WORKER_FEDERATION_MAX_BODY_BYTES
+});
+exports.WORKER_FEDERATION_MAX_BODY_BYTES = __webpack_exports__.WORKER_FEDERATION_MAX_BODY_BYTES;
+exports.WorkerFederationBodyTooLargeError = __webpack_exports__.WorkerFederationBodyTooLargeError;
+exports.assertWorkerFederationBodySize = __webpack_exports__.assertWorkerFederationBodySize;
+exports.checkWorkerFederationDeadline = __webpack_exports__.checkWorkerFederationDeadline;
+exports.readWorkerFederationJsonBody = __webpack_exports__.readWorkerFederationJsonBody;
+exports.workerAbortReason = __webpack_exports__.workerAbortReason;
+exports.workerAbortable = __webpack_exports__.workerAbortable;
+exports.workerFederationErrorMessage = __webpack_exports__.workerFederationErrorMessage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WORKER_FEDERATION_MAX_BODY_BYTES",
+    "WorkerFederationBodyTooLargeError",
+    "assertWorkerFederationBodySize",
+    "checkWorkerFederationDeadline",
+    "readWorkerFederationJsonBody",
+    "workerAbortReason",
+    "workerAbortable",
+    "workerFederationErrorMessage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,272 @@
+"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__, {
+    createWorkerFederationTransport: ()=>createWorkerFederationTransport
+});
+const external_contract_js_namespaceObject = require("./contract.js");
+const external_lease_js_namespaceObject = require("./lease.js");
+async function readResponseJson(response, expectedUrl, signal, checkDeadline) {
+    const cancelBody = ()=>{
+        response.body?.cancel().catch(()=>void 0);
+    };
+    if (signal.aborted) {
+        cancelBody();
+        throw (0, external_lease_js_namespaceObject.workerAbortReason)(signal);
+    }
+    try {
+        checkDeadline();
+    } catch (error) {
+        cancelBody();
+        throw error;
+    }
+    if (!response.ok || response.redirected || response.url && response.url !== expectedUrl) {
+        cancelBody();
+        throw new Error(`Worker federation publication request failed (${response.status}).`);
+    }
+    if (!response.body) throw new Error('Worker federation response has no body.');
+    return (0, external_lease_js_namespaceObject.readWorkerFederationJsonBody)(response.body, signal, response.headers.get('content-length'), checkDeadline);
+}
+async function fetchJson(fetchResponse, request, signal, checkDeadline) {
+    checkDeadline();
+    if (signal.aborted) throw (0, external_lease_js_namespaceObject.workerAbortReason)(signal);
+    const pending = fetchResponse(request);
+    pending.then((response)=>{
+        if (signal.aborted) response.body?.cancel().catch(()=>void 0);
+    }, ()=>void 0);
+    return readResponseJson(await (0, external_lease_js_namespaceObject.workerAbortable)(pending, signal), request.url, signal, checkDeadline);
+}
+function createWorkerFederationTransport(options) {
+    const timeout = options.requestTimeout ?? 3000;
+    const admitRendererContract = options.admitRendererContract;
+    if ('function' != typeof admitRendererContract) throw new Error('Worker federation requires canonical renderer admission.');
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Worker federation requires a positive request deadline.');
+    const services = new Map();
+    for (const service of options.services){
+        if (!service.remote || services.has(service.remote)) throw new Error('Worker federation service remotes must be unique.');
+        const exposes = new Set();
+        for (const fragment of service.fragments){
+            Object.values(fragment.paths).forEach(external_contract_js_namespaceObject.readWorkerFederationPath);
+            if (!fragment.boundaryId || exposes.has(fragment.expose)) throw new Error('Worker federation service exposes must be explicit and unique.');
+            exposes.add(fragment.expose);
+        }
+        const captured = {
+            ...service,
+            manifestUrl: (0, external_contract_js_namespaceObject.readWorkerFederationManifestUrl)(service.manifestUrl).href,
+            fetch: service.fetch.bind(service),
+            fragments: service.fragments.map((fragment)=>Object.freeze({
+                    ...fragment,
+                    paths: Object.freeze({
+                        ...fragment.paths
+                    })
+                }))
+        };
+        services.set(service.remote, captured);
+        if (service.alias && service.alias !== service.remote) {
+            if (services.has(service.alias)) throw new Error('Worker federation service aliases must be unique.');
+            services.set(service.alias, captured);
+        }
+    }
+    const snapshots = new Map();
+    const admissions = new Map();
+    const fetchManifest = options.fetchManifest;
+    let retired;
+    const onOwnerAbort = ()=>dispose((0, external_lease_js_namespaceObject.workerAbortReason)(options.signal));
+    function checkDocumentLiveness() {
+        if (retired) throw retired.reason;
+    }
+    function dispose(reason = new DOMException('The Worker federation document was disposed', 'AbortError')) {
+        if (retired) return;
+        retired = {
+            reason
+        };
+        options.signal?.removeEventListener('abort', onOwnerAbort);
+        for (const pending of [
+            ...snapshots.values(),
+            ...admissions.values()
+        ])pending.controller.abort(reason);
+        snapshots.clear();
+        admissions.clear();
+    }
+    if (options.signal?.aborted) onOwnerAbort();
+    else options.signal?.addEventListener('abort', onOwnerAbort, {
+        once: true
+    });
+    function serviceCoordinate(remote, expose, locale) {
+        const service = services.get(remote);
+        const fragment = service?.fragments.find((value)=>value.expose === expose);
+        if (!service || !fragment || !Object.hasOwn(fragment.paths, locale)) throw new Error('Worker federation remote/expose has no configured service binding.');
+        return {
+            service,
+            fragment
+        };
+    }
+    async function shared(cache, key, operation, signal, deadlineAt = performance.now() + timeout, retainFulfilled = true) {
+        checkDocumentLiveness();
+        if (signal?.aborted) throw (0, external_lease_js_namespaceObject.workerAbortReason)(signal);
+        let pending = cache.get(key);
+        if (!pending) {
+            const controller = new AbortController();
+            const checkDeadline = ()=>(0, external_lease_js_namespaceObject.checkWorkerFederationDeadline)(deadlineAt, controller.signal, controller);
+            const deadline = setTimeout(()=>controller.abort(new Error('Worker federation request deadline exceeded.')), Math.max(0, deadlineAt - performance.now()));
+            const promise = operation(controller.signal, checkDeadline);
+            pending = {
+                controller,
+                promise,
+                waiters: 0,
+                settled: false
+            };
+            const captured = pending;
+            cache.set(key, captured);
+            promise.then(()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (!retainFulfilled && cache.get(key) === captured) cache.delete(key);
+            }, ()=>{
+                captured.settled = true;
+                clearTimeout(deadline);
+                if (cache.get(key) === captured) cache.delete(key);
+            });
+        }
+        const captured = pending;
+        captured.waiters++;
+        try {
+            const value = await (signal ? (0, external_lease_js_namespaceObject.workerAbortable)(captured.promise, signal) : captured.promise);
+            checkDocumentLiveness();
+            (0, external_lease_js_namespaceObject.checkWorkerFederationDeadline)(deadlineAt, signal);
+            return value;
+        } finally{
+            captured.waiters--;
+            if (!captured.settled && 0 === captured.waiters) {
+                captured.controller.abort(new Error('Worker federation request has no active consumers.'));
+                if (cache.get(key) === captured) cache.delete(key);
+            }
+        }
+    }
+    function admitWithin({ remote, expose, locale, signal }, deadlineAt = performance.now() + timeout) {
+        const { service, fragment } = serviceCoordinate(remote, expose, locale);
+        const key = (0, external_contract_js_namespaceObject.workerFederationWireJson)([
+            service.remote,
+            expose,
+            locale
+        ]);
+        const promise = shared(admissions, key, async (signal, checkDeadline)=>{
+            checkDeadline();
+            const request = new Request(service.manifestUrl, {
+                redirect: 'manual',
+                signal
+            });
+            const manifest = await fetchJson(fetchManifest ?? service.fetch, request, signal, checkDeadline);
+            const styles = (0, external_contract_js_namespaceObject.readWorkerFederationStyles)({
+                manifest,
+                manifestUrl: request.url,
+                expose
+            });
+            const admitted = (0, external_contract_js_namespaceObject.admitWorkerFederationExpose)({
+                manifest,
+                manifestUrl: request.url,
+                remote: service.remote,
+                expose,
+                locale,
+                admitRendererContract
+            });
+            checkDeadline();
+            if (admitted.coordinate.boundaryId !== fragment.boundaryId || admitted.path !== fragment.paths[locale]) throw new Error('Worker federation publication conflicts with its service coordinate.');
+            return Object.freeze({
+                ...admitted,
+                styles
+            });
+        }, signal, deadlineAt);
+        return {
+            promise,
+            key,
+            pending: admissions.get(key)
+        };
+    }
+    return {
+        dispose,
+        admit: (options)=>admitWithin(options).promise,
+        async request ({ remote, expose, locale, payload, signal }) {
+            const deadlineAt = performance.now() + timeout;
+            checkDocumentLiveness();
+            if (signal?.aborted) throw (0, external_lease_js_namespaceObject.workerAbortReason)(signal);
+            const { service } = serviceCoordinate(remote, expose, locale);
+            if ('string' == typeof payload) (0, external_lease_js_namespaceObject.assertWorkerFederationBodySize)(payload);
+            const encodedPayload = (0, external_lease_js_namespaceObject.assertWorkerFederationBodySize)((0, external_contract_js_namespaceObject.workerFederationWireJson)(payload));
+            const key = (0, external_contract_js_namespaceObject.workerFederationWireJson)([
+                service.remote,
+                expose,
+                locale,
+                encodedPayload
+            ]);
+            (0, external_lease_js_namespaceObject.checkWorkerFederationDeadline)(deadlineAt, signal);
+            return shared(snapshots, key, async (signal, checkDeadline)=>{
+                checkDeadline();
+                const admission = admitWithin({
+                    remote,
+                    expose,
+                    locale,
+                    signal
+                }, deadlineAt);
+                const admitted = await admission.promise;
+                checkDeadline();
+                try {
+                    const body = (0, external_lease_js_namespaceObject.assertWorkerFederationBodySize)((0, external_contract_js_namespaceObject.workerFederationWireJson)((0, external_contract_js_namespaceObject.workerFederationEnvelope)('request', admitted, JSON.parse(encodedPayload))));
+                    checkDeadline();
+                    const response = await fetchJson(service.fetch, new Request(admitted.endpoint, {
+                        method: 'POST',
+                        headers: {
+                            'content-type': 'application/json'
+                        },
+                        body,
+                        redirect: 'manual',
+                        signal
+                    }), signal, checkDeadline);
+                    checkDeadline();
+                    const decodedPayload = (0, external_contract_js_namespaceObject.readWorkerFederationEnvelope)(response, 'response', admitted);
+                    checkDeadline();
+                    return {
+                        admitted,
+                        payload: decodedPayload
+                    };
+                } catch (error) {
+                    if (!signal.aborted && admissions.get(admission.key) === admission.pending) admissions.delete(admission.key);
+                    throw error;
+                }
+            }, signal, deadlineAt, false);
+        }
+    };
+}
+exports.createWorkerFederationTransport = __webpack_exports__.createWorkerFederationTransport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWorkerFederationTransport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/adapter.mjs

@@ -15,7 +15,7 @@ function defineRendererAdapter(adapter) {
 function nativeRendererDependencies(profile) {
     return {
         ...Object.fromEntries(Object.entries(profile.dependencies).filter(([name])=>!name.startsWith('@modern-js/'))),
-        [profile.router.coreName]: profile.router.coreVersion
+        [profile.router.coreName]: profile.dependencies[profile.router.coreName] ?? profile.router.coreVersion
     };
 }
 export { defineRendererAdapter, nativeRendererDependencies };

package/dist/esm/data/codec.mjs

@@ -1,6 +1,6 @@
 import { fromJSON, toJSON } from "seroval";
 import { validateSerializedData } from "./tree.mjs";
-const DATA_CODEC = 'seroval-json@1.6.8';
+const DATA_CODEC = 'seroval-json@1.6.9';
 const MAX_DATA_BYTES = 1048576;
 const MAX_DEPTH = 100;
 const MAX_NODES = 20000;

package/dist/esm/entry-client.mjs

@@ -69,6 +69,11 @@ function startNativeClientEntry(options, adapter) {
                 rewrite: i18n.rewrite(()=>current.language)
             } : {}
         });
+        const releaseRouter = ()=>adapter.disposeRouter(router);
+        if (signal.aborted) releaseRouter();
+        else signal.addEventListener('abort', releaseRouter, {
+            once: true
+        });
         const stopSync = i18n && current ? i18n.syncWithRouter(router, current) : void 0;
         if (stopSync) signal.addEventListener('abort', stopSync, {
             once: true

package/dist/esm/federation.mjs

@@ -1,3 +1,4 @@
+const LOAD_WITH_CAPTURE = Symbol.for('ultramodern.federation.load-with-capture');
 function getFederationHost(binding) {
     if (void 0 === binding) return;
     if ('function' != typeof binding?.instance) throw new TypeError('The native federation host binding is invalid.');
@@ -7,16 +8,24 @@ function getFederationHost(binding) {
 }
 async function loadFederatedModule(instance, id) {
     if (!instance) throw new Error(`Cannot load ${id}: this application has no Module Federation runtime. Add module-federation.config.ts with its remotes.`);
-    const module = await instance.loadRemote(id);
+    const coupledLoad = instance[LOAD_WITH_CAPTURE];
+    const result = coupledLoad ? await coupledLoad(id, (_module, resolution)=>remoteBrowserAssets(instance, id, resolution)) : {
+        module: await instance.loadRemote(id),
+        captured: remoteBrowserAssets(instance, id)
+    };
+    const module = result.module;
     if (!module) throw new Error(`Remote module ${id} is unavailable`);
-    return module;
+    return {
+        module,
+        assets: result.captured
+    };
 }
-function remoteBrowserAssets(instance, id) {
+function remoteBrowserAssets(instance, id, resolution) {
     const target = instance.remoteHandler?.idToRemoteMap?.[id];
     const loaded = target && instance.moduleCache?.get(target.name);
-    const snapshot = loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
+    const snapshot = resolution ? resolution.remoteSnapshot : loaded && instance.snapshotHandler?.getGlobalRemoteInfo(loaded.remoteInfo).remoteSnapshot;
     if (!snapshot || 'string' != typeof snapshot.publicPath || !snapshot.publicPath || 'string' != typeof snapshot.remoteEntry || !snapshot.remoteEntry) return;
-    const expose = snapshot.modules?.find((module)=>module.modulePath === target.expose);
+    const expose = snapshot.modules?.find((module)=>module.modulePath === (resolution?.expose ?? target?.expose));
     if (!expose?.assets) return;
     const publicPath = snapshot.publicPath;
     const url = (file)=>/^(?:https?:)?\/\//iu.test(file) ? file : `${publicPath.replace(/\/$/u, '')}/${file.replace(/^\//u, '')}`;

package/dist/esm/server/worker.mjs

@@ -28,7 +28,8 @@ function dispatchNativeWorkerRequest(request, options) {
                 ...resources.serverConfig,
                 forceCSR
             },
-            nonce: resources.nonce
+            nonce: resources.nonce,
+            workerFederation: options.workerFederation
         }
     });
 }