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

package/dist/cjs/module-federation/native-browser-dev-client.js

@@ -0,0 +1,320 @@
+"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__, {
+    prepareNativeBrowserDevClient: ()=>prepareNativeBrowserDevClient,
+    releaseNativeBrowserDevClient: ()=>releaseNativeBrowserDevClient,
+    startNativeBrowserDevClient: ()=>startNativeBrowserDevClient
+});
+const external_native_browser_dev_refresh_js_namespaceObject = require("./native-browser-dev-refresh.js");
+const external_native_browser_dev_runtime_plugin_js_namespaceObject = require("./native-browser-dev-runtime-plugin.js");
+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 ((0, external_native_browser_dev_runtime_plugin_js_namespaceObject.hasNativeBrowserDevPublisher)(options.remoteName)) {
+                const graph = await (0, external_native_browser_dev_runtime_plugin_js_namespaceObject.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 (0, external_native_browser_dev_runtime_plugin_js_namespaceObject.replaceNativeBrowserDevRemote)(graph);
+                    } catch (error) {
+                        if (running && !signal.aborted && (0, external_native_browser_dev_runtime_plugin_js_namespaceObject.hasNativeBrowserDevPublisher)(options.remoteName) && (0, external_native_browser_dev_refresh_js_namespaceObject.isNativeBrowserDevCommitError)(error, graph.revision)) {
+                            state.failure = {
+                                runtimeHash: graph.runtimeHash,
+                                error
+                            };
+                            report(error);
+                            commitClient(options.remoteName, graph);
+                        }
+                        throw error;
+                    }
+                    if (!running || signal.aborted || !(0, external_native_browser_dev_runtime_plugin_js_namespaceObject.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);
+    };
+}
+exports.prepareNativeBrowserDevClient = __webpack_exports__.prepareNativeBrowserDevClient;
+exports.releaseNativeBrowserDevClient = __webpack_exports__.releaseNativeBrowserDevClient;
+exports.startNativeBrowserDevClient = __webpack_exports__.startNativeBrowserDevClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "prepareNativeBrowserDevClient",
+    "releaseNativeBrowserDevClient",
+    "startNativeBrowserDevClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/module-federation/native-browser-dev-refresh.js

@@ -0,0 +1,226 @@
+"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__);
+const COMMIT_ERROR = Symbol.for('ultramodern.federation.browser-dev-commit-error.v1');
+class NativeBrowserDevCommitError extends Error {
+    constructor(revision, cause){
+        super(`Native browser refresh failed after ownership transfer began: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause
+        }), this[COMMIT_ERROR] = true;
+        this.name = 'NativeBrowserDevCommitError';
+        Object.defineProperty(this, 'revision', {
+            value: revision,
+            enumerable: true
+        });
+    }
+}
+function isNativeBrowserDevCommitError(error, revision) {
+    return error instanceof Error && true === Reflect.get(error, COMMIT_ERROR) && Reflect.get(error, 'revision') === revision;
+}
+function nativeBrowserDevCommitFailure(revision, cause) {
+    return new NativeBrowserDevCommitError(revision, cause);
+}
+const selectedShares = (host)=>Object.entries(host.shareScopeMap).flatMap(([scope, packages])=>Object.entries(packages).flatMap(([name, versions])=>Object.entries(versions).filter(([, provider])=>provider.loaded || provider.loading).map(([version, provider])=>({
+                    scope,
+                    name,
+                    version,
+                    provider,
+                    lib: provider.lib,
+                    get: provider.get
+                }))));
+function assertSelectedShares(host, shares) {
+    for (const share of shares){
+        const provider = host.shareScopeMap[share.scope]?.[share.name]?.[share.version];
+        if (provider !== share.provider || provider.lib !== share.lib || provider.get !== share.get) throw new Error(`Native browser refresh changed the selected shared provider ${share.name}.`);
+    }
+}
+function createNativeBrowserDevRefresh(options) {
+    let active;
+    let pending;
+    let disposed = false;
+    const consumed = new Set();
+    const recovery = new Set();
+    const released = new WeakSet();
+    const release = (stage)=>{
+        if (released.has(stage)) return;
+        released.add(stage);
+        try {
+            stage.release();
+        } finally{
+            stage.host.moduleCache.clear();
+        }
+    };
+    return {
+        replace (graph) {
+            if (disposed) return Promise.reject(new Error('Native browser refresh is disposed.'));
+            if (pending) return Promise.reject(new Error('Native browser refresh already has an active replacement.'));
+            if (!/^[a-f0-9]{64}$/u.test(graph.revision)) return Promise.reject(new Error('Native browser graph revision is invalid.'));
+            if (consumed.has(graph.revision)) return Promise.reject(new Error('Native browser graph was already consumed; rebuild before retrying.'));
+            const commitErrors = new WeakSet();
+            const task = (async ()=>{
+                const host = options.host;
+                const shares = selectedShares(host);
+                const replacement = options.prepareReplacement(options.boundary);
+                const stage = options.createHost({
+                    ...host.options,
+                    name: `${host.name}:native-dev:${graph.revision}`,
+                    id: `${host.name}:native-dev:${graph.revision}`,
+                    remotes: [
+                        {
+                            ...graph.remote
+                        }
+                    ],
+                    shared: {}
+                });
+                if (stage.host === host || stage.host === active?.host) throw new Error('Native browser refresh requires an isolated staging host.');
+                let accepted = false;
+                let module;
+                let failed = false;
+                let failure;
+                try {
+                    for (const [name, scope] of Object.entries(host.shareScopeMap)){
+                        stage.host.initShareScopeMap(name, scope, {
+                            hostShareScopeMap: host.shareScopeMap
+                        });
+                        if (stage.host.shareScopeMap[name] !== scope) throw new Error('Native browser refresh lost the actual shared scope.');
+                    }
+                    const factory = await stage.host.loadRemote(options.id, {
+                        loadFactory: false
+                    });
+                    if (disposed) throw new Error('Native browser refresh was disposed while loading.');
+                    if ('function' != typeof factory) throw new Error('Native browser refresh did not receive an exposed factory.');
+                    assertSelectedShares(host, shares);
+                    stage.prepareFactory?.();
+                    consumed.add(graph.revision);
+                    try {
+                        module = replacement.execute(factory);
+                    } catch (error) {
+                        if (replacement.commitStarted) {
+                            if (active) recovery.add(active);
+                            active = stage;
+                            accepted = true;
+                        }
+                        throw error;
+                    }
+                    const previous = active;
+                    active = stage;
+                    accepted = true;
+                    assertSelectedShares(host, shares);
+                    const retired = new Set(recovery);
+                    recovery.clear();
+                    if (previous) retired.add(previous);
+                    const errors = [];
+                    for (const retained of retired)try {
+                        release(retained);
+                    } catch (error) {
+                        errors.push(error);
+                    }
+                    if (errors.length) throw new AggregateError(errors, 'Native browser refresh retirement failed.');
+                } catch (error) {
+                    failed = true;
+                    failure = error;
+                }
+                const retired = new Set();
+                if (disposed && active === stage) {
+                    active = void 0;
+                    for (const retained of recovery)retired.add(retained);
+                    recovery.clear();
+                    retired.add(stage);
+                } else if (!accepted) retired.add(stage);
+                const cleanupErrors = [];
+                for (const retained of retired)try {
+                    release(retained);
+                } catch (error) {
+                    cleanupErrors.push(error);
+                }
+                if (cleanupErrors.length) {
+                    failure = new AggregateError(failed ? [
+                        failure,
+                        ...cleanupErrors
+                    ] : cleanupErrors, 'Native browser refresh cleanup failed.');
+                    failed = true;
+                }
+                if (failed) {
+                    if (accepted) {
+                        const committedFailure = nativeBrowserDevCommitFailure(graph.revision, failure);
+                        commitErrors.add(committedFailure);
+                        throw committedFailure;
+                    }
+                    throw failure;
+                }
+                return module;
+            })().catch((error)=>{
+                if (error instanceof Error && true === Reflect.get(error, COMMIT_ERROR) && !commitErrors.has(error)) throw new Error(`Native browser graph failed before its own ownership transfer: ${error.message}`, {
+                    cause: error
+                });
+                throw error;
+            });
+            pending = task;
+            task.finally(()=>{
+                if (pending === task) pending = void 0;
+            }).catch(()=>{});
+            return task;
+        },
+        get activeHost () {
+            return active?.host ?? options.host;
+        },
+        dispose () {
+            if (disposed) return;
+            disposed = true;
+            const previous = active;
+            active = void 0;
+            const retained = new Set(recovery);
+            recovery.clear();
+            if (previous) retained.add(previous);
+            const errors = [];
+            for (const stage of retained)try {
+                release(stage);
+            } catch (error) {
+                errors.push(error);
+            }
+            if (errors.length) throw new AggregateError(errors, 'Native browser refresh cleanup failed.');
+        }
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    createNativeBrowserDevRefresh: ()=>createNativeBrowserDevRefresh,
+    isNativeBrowserDevCommitError: ()=>isNativeBrowserDevCommitError,
+    nativeBrowserDevCommitFailure: ()=>nativeBrowserDevCommitFailure
+});
+exports.createNativeBrowserDevRefresh = __webpack_exports__.createNativeBrowserDevRefresh;
+exports.isNativeBrowserDevCommitError = __webpack_exports__.isNativeBrowserDevCommitError;
+exports.nativeBrowserDevCommitFailure = __webpack_exports__.nativeBrowserDevCommitFailure;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeBrowserDevRefresh",
+    "isNativeBrowserDevCommitError",
+    "nativeBrowserDevCommitFailure"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});