@bleedingdev/modern-js-federation-runtime 3.9.3-ultramodern.8 → 3.9.3-ultramodern.9

package/dist/esm/module-federation/native-dev-refresh-runtime-plugin.mjs

@@ -0,0 +1,229 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const LOAD_WITH_CAPTURE = Symbol.for('ultramodern.federation.load-with-capture');
+function nativeDevRefreshRuntimePlugin(options) {
+    if (!options.revisionHeader || !Number.isSafeInteger(options.requestTimeout) || options.requestTimeout <= 0) throw new TypeError('Native federation dev refresh requires a bounded revision probe.');
+    const hosts = new WeakMap();
+    const calls = new AsyncLocalStorage();
+    const probe = (host, lane, expose)=>{
+        if (lane.probe) return lane.probe;
+        const info = lane.info;
+        if (!info) throw new Error('Native federation dev remote has no admitted entry.');
+        const pending = (async ()=>{
+            const init = {
+                method: 'HEAD',
+                cache: 'no-store',
+                signal: AbortSignal.timeout(options.requestTimeout)
+            };
+            let clearDeadline;
+            const signal = init.signal;
+            const deadline = new Promise((_resolve, reject)=>{
+                const abort = ()=>reject(signal.reason);
+                signal.addEventListener('abort', abort, {
+                    once: true
+                });
+                clearDeadline = ()=>signal.removeEventListener('abort', abort);
+            });
+            const request = (async ()=>{
+                const hooked = await host.loaderHook.lifecycle.fetch.emit(info.entry, init, info, {
+                    initiator: 'loadRemote',
+                    id: expose && '.' !== expose ? `${info.name}/${expose.replace(/^\.\//u, '')}` : info.name,
+                    resourceType: 'remoteEntry',
+                    url: info.entry,
+                    expose
+                });
+                const response = hooked instanceof Response ? hooked : await globalThis.fetch(info.entry, init);
+                if (signal.aborted) {
+                    response.body?.cancel().catch(()=>{});
+                    throw signal.reason;
+                }
+                return response;
+            })();
+            let response;
+            try {
+                response = await Promise.race([
+                    request,
+                    deadline
+                ]);
+            } finally{
+                clearDeadline();
+            }
+            response.body?.cancel().catch(()=>{});
+            if (!response.ok) throw Object.assign(new Error(`Native federation dev revision request failed: ${response.status} ${info.entry}`), {
+                status: response.status
+            });
+            const revision = response.headers.get(options.revisionHeader);
+            if (null !== revision && !/^[a-f0-9]{64}$/u.test(revision)) throw new Error('Native federation dev remote returned an invalid graph revision.');
+            if (null === revision && 'string' == typeof lane.revision) throw new Error('Native federation dev remote lost its completed graph revision.');
+            return revision;
+        })();
+        lane.probe = pending;
+        const clear = ()=>{
+            if (lane.probe === pending) lane.probe = void 0;
+        };
+        pending.then(clear, clear);
+        return pending;
+    };
+    return {
+        name: 'ultramodern-native-federation-dev-refresh',
+        beforeInit (args) {
+            const host = args.origin;
+            if (hosts.has(host)) return args;
+            const lanes = new Map(options.remotes.map((remote)=>[
+                    remote.name,
+                    {
+                        remote: {
+                            ...remote
+                        },
+                        active: new Set()
+                    }
+                ]));
+            hosts.set(host, lanes);
+            const load = host.loadRemote.bind(host);
+            const loadWithCapture = async (id, loadOptions, capture)=>{
+                const parent = calls.getStore();
+                const lease = {
+                    host,
+                    ...parent?.host === host ? {
+                        parent
+                    } : {}
+                };
+                return calls.run(lease, async ()=>{
+                    let success = false;
+                    try {
+                        const module = await load(id, loadOptions);
+                        const captured = capture?.(module, lease.resolution);
+                        success = null !== module && true === lease.admitted;
+                        return {
+                            module,
+                            captured
+                        };
+                    } finally{
+                        lease.active = false;
+                        lease.release?.(success);
+                    }
+                });
+            };
+            host.loadRemote = async (id, loadOptions)=>(await loadWithCapture(id, loadOptions)).module;
+            host[LOAD_WITH_CAPTURE] = (id, capture)=>loadWithCapture(id, void 0, capture);
+            return args;
+        },
+        async beforeRequest (args) {
+            const lease = calls.getStore();
+            if (!lease || lease.host !== args.origin) return args;
+            const lane = [
+                ...hosts.get(args.origin)?.values() ?? []
+            ].find(({ remote })=>[
+                    remote.alias,
+                    remote.name
+                ].some((name)=>args.id === name || args.id.startsWith(`${name}/`)));
+            if (!lane || lease.lane) return args;
+            lease.lane = lane;
+            const prefix = [
+                lane.remote.alias,
+                lane.remote.name
+            ].find((name)=>args.id === name || args.id.startsWith(`${name}/`));
+            const expose = args.id === prefix ? '.' : `./${args.id.slice(prefix.length + 1)}`;
+            for(let ancestor = lease.parent; ancestor; ancestor = ancestor.parent)if (ancestor.lane === lane && ancestor.active) {
+                let release;
+                const finished = new Promise((resolve)=>{
+                    release = resolve;
+                });
+                lane.active.add(finished);
+                lease.active = true;
+                lease.snapshot = ancestor.snapshot;
+                lease.release = ()=>{
+                    lane.active.delete(finished);
+                    release();
+                };
+                return args;
+            }
+            for(;;){
+                if (lane.transition) {
+                    await lane.transition;
+                    continue;
+                }
+                const revision = void 0 === lane.revision ? void 0 : null === lane.revision ? null : await probe(args.origin, lane, expose);
+                if (lane.transition) {
+                    await lane.transition;
+                    continue;
+                }
+                let finish;
+                const finished = new Promise((resolve)=>{
+                    finish = resolve;
+                });
+                if (void 0 === lane.revision || revision !== lane.revision) {
+                    lane.transition = finished;
+                    lease.release = (success)=>{
+                        if (success) lane.revision = lane.candidate ?? null;
+                        if (lane.transition === finished) lane.transition = void 0;
+                        finish();
+                    };
+                    while(lane.active.size)await Promise.allSettled([
+                        ...lane.active
+                    ]);
+                    lane.candidate = revision;
+                    if (void 0 !== lane.revision) {
+                        lease.active = true;
+                        lease.snapshot = lane.snapshot;
+                        const retained = new Set();
+                        for (const scope of Object.values(args.origin.shareScopeMap ?? {}))for (const [pkgName, versions] of Object.entries(scope))if (options.shared?.some((key)=>key === pkgName || key.endsWith('/') && pkgName.startsWith(key)) && Object.values(versions).some((shared)=>shared.loaded || shared.loading || shared.lib)) retained.add(pkgName);
+                        for (const pkgName of retained){
+                            if (!args.origin.loadShare) throw new TypeError('Native federation dev refresh requires the host share lifecycle.');
+                            await args.origin.loadShare(pkgName);
+                        }
+                        while(lane.active.size)await Promise.allSettled([
+                            ...lane.active
+                        ]);
+                        args.origin.registerRemotes([
+                            {
+                                ...lane.remote
+                            }
+                        ], {
+                            force: true
+                        });
+                        lease.snapshot = void 0;
+                    }
+                } else {
+                    lane.active.add(finished);
+                    lease.release = ()=>{
+                        lane.active.delete(finished);
+                        finish();
+                    };
+                }
+                lease.active = true;
+                return args;
+            }
+        },
+        loadSnapshot (args) {
+            const lease = calls.getStore();
+            if (!lease || args.options !== lease.host.options || args.moduleInfo.name !== lease.lane?.remote.name) return args;
+            if (void 0 !== lease.snapshot) return {
+                ...args,
+                remoteSnapshot: lease.snapshot
+            };
+            lease.snapshot = args.remoteSnapshot;
+            return args;
+        },
+        afterLoadSnapshot (args) {
+            const lease = calls.getStore();
+            if (lease?.host === args.host && args.moduleInfo.name === lease.lane?.remote.name) lease.snapshot = args.remoteSnapshot;
+            return args;
+        },
+        async afterResolve (args) {
+            const lane = hosts.get(args.origin)?.get(args.remote.name);
+            const lease = calls.getStore();
+            if (!lane || lease?.host !== args.origin || lease.lane !== lane || !lease.active) return args;
+            if (lane.info?.entry !== args.remoteInfo.entry) lane.candidate = void 0;
+            lane.info = args.remoteInfo;
+            if (void 0 === lane.candidate) lane.candidate = await probe(args.origin, lane, args.expose);
+            lease.admitted = true;
+            lane.snapshot = args.remoteSnapshot;
+            lease.resolution = {
+                remoteSnapshot: args.remoteSnapshot,
+                expose: args.expose
+            };
+            return args;
+        }
+    };
+}
+export default nativeDevRefreshRuntimePlugin;

package/dist/esm/module-federation/renderer-runtime-plugin.mjs

@@ -109,6 +109,9 @@ function createRendererFederationRuntimePlugin(options) {
     const observedEntries = new WeakMap();
     const acceptedEntries = new Set();
     const versions = rendererShareVersions(expected);
+    const sharedVersion = (name)=>versions.get(name) ?? ('react' === expected.profile.renderer ? void 0 : [
+            ...versions
+        ].find(([owner])=>name.startsWith(`${owner}/`))?.[1]);
     return {
         name: 'ultramodern-renderer-federation-contract',
         beforeRegisterRemote (args) {
@@ -182,7 +185,7 @@ function createRendererFederationRuntimePlugin(options) {
             return args;
         },
         resolveShare (args) {
-            const version = versions.get(args.pkgName);
+            const version = sharedVersion(args.pkgName);
             if (void 0 === version) return args;
             const resolve = args.resolver;
             return {
@@ -207,7 +210,7 @@ function createRendererFederationRuntimePlugin(options) {
             };
         },
         afterLoadShare (args) {
-            if (versions.has(args.pkgName) && args.selectedShared) {
+            if (void 0 !== sharedVersion(args.pkgName) && args.selectedShared) {
                 const shared = record(args.selectedShared.treeShaking) && args.selectedShared.treeShaking.loaded ? args.selectedShared.treeShaking : args.selectedShared;
                 selected.set(args.pkgName, Object.freeze({
                     lib: shared.lib,

package/dist/esm-node/module-federation/native-browser-dev-client.mjs

@@ -0,0 +1,277 @@
+import "node:module";
+import { isNativeBrowserDevCommitError } from "./native-browser-dev-refresh.mjs";
+import { hasNativeBrowserDevPublisher, readNativeBrowserDevPublication, replaceNativeBrowserDevRemote } from "./native-browser-dev-runtime-plugin.mjs";
+const CLIENTS = Symbol.for('ultramodern.federation.browser-dev-clients.v1');
+const clients = ()=>{
+    const root = globalThis;
+    if (!root[CLIENTS]) Object.defineProperty(root, CLIENTS, {
+        value: new Map()
+    });
+    return root[CLIENTS];
+};
+function commitClient(remoteName, graph) {
+    const state = clients().get(remoteName);
+    const next = state?.candidates.get(graph.runtimeHash)?.deref();
+    if (!state || !next) throw new Error('Accepted native graph has no matching fresh HMR runtime.');
+    if (state.active === next) return;
+    state.active?.stop();
+    state.active = next;
+    next.start();
+}
+function prepareNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    const candidate = hash && clients().get(remoteName)?.candidates.get(hash)?.deref();
+    if (!candidate) throw new Error('Native graph has no loaded standby HMR runtime.');
+    return candidate.lease();
+}
+function releaseNativeBrowserDevClient(remoteName, manifest) {
+    const hash = /\/__ultramodern_mf__\/([a-f0-9]+)\//u.exec(new URL(manifest).pathname)?.[1];
+    if (!hash) return;
+    const state = clients().get(remoteName);
+    const candidate = state?.candidates.get(hash)?.deref();
+    if (!state || !candidate) return;
+    candidate.releaseStandby();
+}
+function startNativeBrowserDevClient(options) {
+    const state = clients().get(options.remoteName) ?? {
+        candidates: new Map()
+    };
+    clients().set(options.remoteName, state);
+    const initialHash = options.hash();
+    let socket;
+    let ping;
+    let reconnect;
+    let reconnectCount = 0;
+    let lastHash;
+    let running = false;
+    let applying;
+    let lifetime;
+    let removeCustom;
+    const custom = new Map();
+    const queued = [];
+    const leases = new Set();
+    const base = options.serverBase.endsWith('/') ? options.serverBase : `${options.serverBase}/`;
+    const report = (error)=>{
+        console.error('[ultramodern] Native federation development update failed:', error);
+        if (false !== options.config.overlay && ('object' != typeof options.config.overlay || false !== options.config.overlay.errors)) options.overlay()?.create('Native federation update failed', String(error));
+    };
+    const send = (message)=>{
+        if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message));
+        else queued.push(message);
+    };
+    const errorMessage = (error)=>error instanceof Error ? error.message : String(error);
+    const onError = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: event.message,
+            name: event.error?.name,
+            stack: event.error?.stack
+        });
+    const onRejected = (event)=>send({
+            type: 'client-error',
+            id: crypto.randomUUID(),
+            message: `Uncaught (in promise) ${errorMessage(event.reason)}`,
+            name: event.reason?.name,
+            stack: event.reason?.stack
+        });
+    const fullReload = (data)=>{
+        if (!options.liveReload) return;
+        if (data?.path?.endsWith('.html')) {
+            const pathname = decodeURI(location.pathname);
+            const target = base + data.path.slice(1);
+            if (pathname !== target && pathname !== target.slice(0, -5) && !(pathname.endsWith('/') && `${pathname}index.html` === target)) return;
+        }
+        location.reload();
+    };
+    const apply = ()=>{
+        if (!running || applying || !lastHash || lastHash === options.hash()) return;
+        const signal = lifetime.signal;
+        const targetHash = lastHash;
+        applying = (async ()=>{
+            if (hasNativeBrowserDevPublisher(options.remoteName)) {
+                const graph = await readNativeBrowserDevPublication(options.remoteName, {
+                    signal: AbortSignal.any([
+                        signal,
+                        AbortSignal.timeout(3000)
+                    ]),
+                    revisionHeader: options.revisionHeader
+                });
+                if (signal.aborted) throw signal.reason;
+                if (graph.buildId !== options.buildId) {
+                    try {
+                        await replaceNativeBrowserDevRemote(graph);
+                    } catch (error) {
+                        if (running && !signal.aborted && hasNativeBrowserDevPublisher(options.remoteName) && isNativeBrowserDevCommitError(error, graph.revision)) {
+                            state.failure = {
+                                runtimeHash: graph.runtimeHash,
+                                error
+                            };
+                            report(error);
+                            commitClient(options.remoteName, graph);
+                        }
+                        throw error;
+                    }
+                    if (!running || signal.aborted || !hasNativeBrowserDevPublisher(options.remoteName)) return;
+                    commitClient(options.remoteName, graph);
+                    return;
+                }
+            }
+            if (!options.hot) return fullReload();
+            if ('idle' !== options.hot.status()) return;
+            try {
+                const updated = await options.hot.check(true);
+                if (!updated) fullReload();
+            } catch (error) {
+                console.error('[rsbuild] HMR update failed, performing full reload:', error);
+                fullReload();
+            }
+        })().catch((error)=>{
+            if (!signal.aborted) report(error);
+        }).finally(()=>{
+            applying = void 0;
+            if (running && !signal.aborted && lastHash !== targetHash) apply();
+        });
+    };
+    const clearOverlayForBuild = ()=>{
+        if (state.failure) {
+            if (!lastHash || lastHash === state.failure.runtimeHash) return;
+            state.failure = void 0;
+        }
+        options.overlay()?.clear();
+    };
+    const message = (event)=>{
+        let value;
+        try {
+            value = JSON.parse(event.data);
+        } catch (error) {
+            report(error);
+            return;
+        }
+        switch(value.type){
+            case 'hash':
+                lastHash = value.data;
+                break;
+            case 'ok':
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'warnings':
+                for (const warning of value.data?.text ?? [])console.warn(warning);
+                clearOverlayForBuild();
+                apply();
+                break;
+            case 'errors':
+                for (const error of value.data?.text ?? [])console.error(error);
+                if (value.data?.html) options.overlay()?.create('Build failed', value.data.html);
+                break;
+            case 'full-reload':
+                fullReload(value.data);
+                break;
+            case 'static-changed':
+                fullReload();
+                break;
+            case 'custom':
+                for (const listener of custom.get(value.data?.event) ?? [])listener(value.data.data);
+                break;
+            case 'resolved-client-error':
+                options.overlay()?.create('Runtime errors', String(value.data?.message ?? ''));
+                break;
+        }
+    };
+    const socketUrl = (fallback)=>{
+        const url = new URL('http://localhost');
+        url.hostname = (fallback ? options.serverHost : options.config.host) || location.hostname;
+        url.port = String((fallback ? options.serverPort : options.config.port) || location.port);
+        url.protocol = options.config.protocol || ('https:' === location.protocol ? 'wss:' : 'ws:');
+        url.pathname = options.config.path;
+        url.searchParams.set('token', options.token);
+        return options.resolveWebSocketUrl?.(url.href) ?? url.href;
+    };
+    const detachSocket = ()=>{
+        clearInterval(ping);
+        ping = void 0;
+        const previous = socket;
+        socket = void 0;
+        if (!previous) return;
+        previous.onopen = previous.onclose = previous.onmessage = previous.onerror = null;
+        previous.close();
+    };
+    const connect = (fallback = false)=>{
+        if (!running) return;
+        socket = new WebSocket(socketUrl(fallback));
+        socket.onopen = ()=>{
+            reconnectCount = 0;
+            ping = setInterval(()=>send({
+                    type: 'ping'
+                }), 30000);
+            for (const item of queued.splice(0))send(item);
+        };
+        socket.onmessage = message;
+        socket.onclose = ()=>{
+            detachSocket();
+            if (!running || reconnectCount >= options.config.reconnect) return;
+            reconnectCount++;
+            reconnect = setTimeout(()=>connect(), 1000 * 1.5 ** reconnectCount);
+        };
+        socket.onerror = ()=>{
+            if (options.resolveWebSocketUrl || fallback || socketUrl(false) === socketUrl(true)) return;
+            detachSocket();
+            connect(true);
+        };
+    };
+    const client = {
+        arm () {
+            removeCustom ??= options.installCustomListeners(custom);
+        },
+        lease () {
+            const lease = {};
+            leases.add(lease);
+            client.arm();
+            return ()=>{
+                if (!leases.delete(lease)) return;
+                client.releaseStandby();
+            };
+        },
+        releaseStandby () {
+            if (state.active !== client && !leases.size) client.stop();
+        },
+        start () {
+            if (running) return;
+            running = true;
+            lifetime = new AbortController();
+            client.arm();
+            if (options.browserLogs) {
+                window.addEventListener('error', onError);
+                window.addEventListener('unhandledrejection', onRejected);
+            }
+            connect();
+        },
+        stop () {
+            if (!running && !removeCustom) return;
+            running = false;
+            lifetime?.abort(new Error('Native browser HMR runtime retired.'));
+            clearTimeout(reconnect);
+            reconnect = void 0;
+            detachSocket();
+            window.removeEventListener('error', onError);
+            window.removeEventListener('unhandledrejection', onRejected);
+            removeCustom?.();
+            removeCustom = void 0;
+            custom.clear();
+            queued.length = 0;
+        }
+    };
+    client.arm();
+    state.candidates.set(initialHash, new WeakRef(client));
+    if (!state.active) {
+        state.active = client;
+        client.start();
+    }
+    return ()=>{
+        client.stop();
+        if (state.active === client) state.active = void 0;
+        if (state.candidates.get(initialHash)?.deref() === client) state.candidates.delete(initialHash);
+        if (!state.active && !state.candidates.size) clients().delete(options.remoteName);
+    };
+}
+export { prepareNativeBrowserDevClient, releaseNativeBrowserDevClient, startNativeBrowserDevClient };