@module-federation/utilities 0.0.0-chore-bump-node-22-20260710161714

package/dist/esm/components/FederationBoundary.mjs

@@ -0,0 +1,35 @@
+import react, { lazy, useMemo } from "react";
+import ErrorBoundary from "./ErrorBoundary.mjs";
+
+
+
+
+
+/**
+ * A fallback component that renders nothing.
+ */ const FallbackComponent = ()=>{
+    return null;
+};
+/**
+ * Wrapper around dynamic import.
+ * Adds error boundaries and fallback options.
+ */ const FederationBoundary = ({ dynamicImporter, fallback = ()=>Promise.resolve(FallbackComponent), customBoundary: CustomBoundary = ErrorBoundary, ...rest })=>{
+    const ImportResult = useMemo(()=>{
+        return /*#__PURE__*/ lazy(()=>dynamicImporter().catch((e)=>{
+                console.error(e);
+                return fallback();
+            }).then((m)=>{
+                return {
+                    //@ts-ignore
+                    default: m.default || m
+                };
+            }));
+    }, [
+        dynamicImporter,
+        fallback
+    ]);
+    return /*#__PURE__*/ react.createElement(CustomBoundary, null, /*#__PURE__*/ react.createElement(ImportResult, rest));
+};
+/* export default */ const components_FederationBoundary = (FederationBoundary);
+
+export default components_FederationBoundary;

package/dist/esm/index.mjs

@@ -0,0 +1,24 @@
+export * from "./types/index.mjs";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export { createRuntimeVariables, getContainer, getModule, injectScript } from "./utils/common.mjs";
+export { isObjectEmpty } from "./utils/isEmpty.mjs";
+export { importRemote } from "./utils/importRemote.mjs";
+export { Logger } from "./Logger.mjs";
+export { getRuntimeRemotes } from "./utils/getRuntimeRemotes.mjs";
+export { importDelegatedModule } from "./utils/importDelegatedModule.mjs";
+export { extractUrlAndGlobal, loadScript } from "./utils/pure.mjs";

package/dist/esm/plugins/DelegateModulesPlugin.mjs

@@ -0,0 +1,81 @@
+class DelegateModulesPlugin {
+    getChunkByName(chunks, name) {
+        for (const chunk of chunks){
+            if (chunk.name === name) {
+                return chunk;
+            }
+        }
+        return undefined;
+    }
+    addDelegatesToChunks(compilation, chunks) {
+        for (const chunk of chunks){
+            this._delegateModules.forEach((module)=>{
+                this.addModuleAndDependenciesToChunk(module, chunk, compilation);
+            });
+        }
+    }
+    addModuleAndDependenciesToChunk(module, chunk, compilation) {
+        if (!compilation.chunkGraph.isModuleInChunk(module, chunk)) {
+            if (this.options.debug) {
+                console.log('adding ', module.identifier(), ' to chunk', chunk.name);
+            }
+            compilation.chunkGraph.connectChunkAndModule(chunk, module);
+        }
+    }
+    removeDelegatesNonRuntimeChunks(compilation, chunks) {
+        for (const chunk of chunks){
+            if (!chunk.hasRuntime()) {
+                this.options.debug && console.log('non-runtime chunk:', chunk.debugId, chunk.id, chunk.name);
+                for (const [id, module] of this._delegateModules){
+                    compilation.chunkGraph.disconnectChunkAndModule(chunk, module);
+                }
+            }
+        }
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('DelegateModulesPlugin', (compilation)=>{
+            compilation.hooks.finishModules.tapAsync('DelegateModulesPlugin', (modules, callback)=>{
+                const { remotes } = this.options;
+                const knownDelegates = new Set(remotes ? Object.values(remotes).map((remote)=>remote.replace('internal ', '')) : []);
+                for (const module of modules){
+                    const normalModule = module;
+                    if (normalModule) {
+                        const mid = normalModule.identifier();
+                        if (normalModule?.userRequest?.startsWith('webpack/container/reference')) {
+                            this._delegateModules.set(mid, normalModule);
+                        }
+                    }
+                    if (normalModule.resource && knownDelegates.has(normalModule.resource)) {
+                        this._delegateModules.set(normalModule.resource, normalModule);
+                    }
+                }
+                callback();
+            });
+            compilation.hooks.optimizeChunks.tap('DelegateModulesPlugin', (chunks)=>{
+                const { runtime, container } = this.options;
+                const runtimeChunk = this.getChunkByName(chunks, runtime);
+                if (!runtimeChunk || !runtimeChunk.hasRuntime()) {
+                    return;
+                }
+                // Get the container chunk if specified
+                const remoteContainer = container ? this.getChunkByName(chunks, container) : null;
+                this.options.debug && console.log(remoteContainer?.name, runtimeChunk.name, this._delegateModules.size);
+                this.addDelegatesToChunks(compilation, [
+                    remoteContainer,
+                    runtimeChunk
+                ].filter(Boolean));
+                this.removeDelegatesNonRuntimeChunks(compilation, chunks);
+            });
+        });
+    }
+    constructor(options){
+        this.options = {
+            debug: false,
+            ...options
+        };
+        this._delegateModules = new Map();
+    }
+}
+/* export default */ const plugins_DelegateModulesPlugin = (DelegateModulesPlugin);
+
+export default plugins_DelegateModulesPlugin;

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,37 @@
+// The module cache
+var __webpack_module_cache__ = {};
+// The require function
+function __webpack_require__(moduleId) {
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+}
+
+// webpack/runtime/global
+(() => {
+__webpack_require__.g = (() => {
+	if (typeof globalThis === 'object') return globalThis;
+	try {
+		return this || new Function('return this')();
+	} catch (e) {
+		if (typeof window === 'object') return window;
+	}
+})();
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+
+export { __webpack_require__ };

package/dist/esm/types/index.mjs

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../../../../webpack/module.d.ts" />
+
+

package/dist/esm/utils/common.mjs

@@ -0,0 +1,116 @@
+import { loadScript } from "./pure.mjs";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+
+
+/* eslint-disable @typescript-eslint/ban-ts-comment */ 
+const createContainerSharingScope = (asyncContainer)=>{
+    // @ts-ignore
+    return asyncContainer.then(function(container) {
+        if (!__webpack_require__.S['default']) {
+            // not always a promise, so we wrap it in a resolve
+            return Promise.resolve(__webpack_require__.I('default')).then(function() {
+                return container;
+            });
+        } else {
+            return container;
+        }
+    }).then(function(container) {
+        try {
+            // WARNING: here might be a potential BUG.
+            //   `container.init` does not return a Promise, and here we do not call `then` on it.
+            // But according to [docs](https://webpack.js.org/concepts/module-federation/#dynamic-remote-containers)
+            //   it must be async.
+            // The problem may be in Proxy in NextFederationPlugin.js.
+            //   or maybe a bug in the webpack itself - instead of returning rejected promise it just throws an error.
+            // But now everything works properly and we keep this code as is.
+            container.init(__webpack_require__.S['default']);
+        } catch (e) {
+        // maybe container already initialized so nothing to throw
+        }
+        return container;
+    });
+};
+/**
+ * Return initialized remote container by remote's key or its runtime remote item data.
+ *
+ * `runtimeRemoteItem` might be
+ *    { global, url } - values obtained from webpack remotes option `global@url`
+ * or
+ *    { asyncContainer } - async container is a promise that resolves to the remote container
+ */ const injectScript = async (keyOrRuntimeRemoteItem)=>{
+    const asyncContainer = loadScript(keyOrRuntimeRemoteItem);
+    return createContainerSharingScope(asyncContainer);
+};
+/**
+ * Creates runtime variables from the provided remotes.
+ * If the value of a remote starts with 'promise ' or 'external ', it is transformed into a function that returns the promise call.
+ * Otherwise, the value is stringified.
+ * @param {Remotes} remotes - The remotes to create runtime variables from.
+ * @returns {Record<string, string>} - The created runtime variables.
+ */ const createRuntimeVariables = (remotes)=>{
+    if (!remotes) {
+        return {};
+    }
+    return Object.entries(remotes).reduce((acc, [key, value])=>{
+        if (value.startsWith('promise ') || value.startsWith('external ')) {
+            const promiseCall = value.split(' ')[1];
+            acc[key] = `function() {
+        return ${promiseCall}
+      }`;
+        } else {
+            acc[key] = JSON.stringify(value);
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Returns initialized webpack RemoteContainer.
+ * If its' script does not loaded - then load & init it firstly.
+ */ const getContainer = async (remoteContainer)=>{
+    if (!remoteContainer) {
+        throw Error(`Remote container options is empty`);
+    }
+    const containerScope = typeof window !== 'undefined' ? window : globalThis.__remote_scope__;
+    let containerKey;
+    if (typeof remoteContainer === 'string') {
+        containerKey = remoteContainer;
+    } else {
+        containerKey = remoteContainer.uniqueKey;
+        if (!containerScope[containerKey]) {
+            const container = await injectScript({
+                global: remoteContainer.global,
+                url: remoteContainer.url
+            });
+            if (!container) {
+                throw Error(`Remote container ${remoteContainer.url} is empty`);
+            }
+        }
+    }
+    return containerScope[containerKey];
+};
+/**
+ * Return remote module from container.
+ * If you provide `exportName` it automatically return exact property value from module.
+ *
+ * @example
+ *   remote.getModule('./pages/index', 'default')
+ */ const getModule = async ({ remoteContainer, modulePath, exportName })=>{
+    const container = await getContainer(remoteContainer);
+    try {
+        const modFactory = await container?.get(modulePath);
+        if (!modFactory) {
+            return undefined;
+        }
+        const mod = modFactory();
+        if (exportName) {
+            return mod && typeof mod === 'object' ? mod[exportName] : undefined;
+        } else {
+            return mod;
+        }
+    } catch (error) {
+        console.error(error);
+        return undefined;
+    }
+};
+
+export { createRuntimeVariables, getContainer, getModule, injectScript };

package/dist/esm/utils/getRuntimeRemotes.mjs

@@ -0,0 +1,50 @@
+import { extractUrlAndGlobal, remoteVars } from "./pure.mjs";
+
+
+
+const getRuntimeRemotes = ()=>{
+    try {
+        return Object.entries(remoteVars).reduce(function(acc, item) {
+            const [key, value] = item;
+            // if its an object with a thenable (eagerly executing function)
+            if (typeof value === 'object' && typeof value.then === 'function') {
+                acc[key] = {
+                    asyncContainer: value
+                };
+            } else if (typeof value === 'function') {
+                // @ts-ignore
+                acc[key] = {
+                    asyncContainer: value
+                };
+            } else if (typeof value === 'string' && value.startsWith('internal ')) {
+                const [request, query] = value.replace('internal ', '').split('?');
+                if (query) {
+                    const remoteSyntax = new URLSearchParams(query).get('remote');
+                    if (remoteSyntax) {
+                        const [url, global] = extractUrlAndGlobal(remoteSyntax);
+                        acc[key] = {
+                            global,
+                            url
+                        };
+                    }
+                }
+            } else if (typeof value === 'string') {
+                const [url, global] = extractUrlAndGlobal(value);
+                acc[key] = {
+                    global,
+                    url
+                };
+            } else {
+                //@ts-ignore
+                console.warn('remotes process', process.env.REMOTES);
+                throw new Error(`[mf] Invalid value received for runtime_remote "${key}"`);
+            }
+            return acc;
+        }, {});
+    } catch (err) {
+        console.warn('Unable to retrieve runtime remotes: ', err);
+    }
+    return {};
+};
+
+export { getRuntimeRemotes };

package/dist/esm/utils/getRuntimeRemotes.test.mjs

@@ -0,0 +1,84 @@
+import { getRuntimeRemotes } from "./getRuntimeRemotes.mjs";
+import { remoteVars } from "./pure.mjs";
+
+
+
+
+
+xdescribe('getRuntimeRemotes', ()=>{
+    afterEach(()=>{
+        Object.keys(remoteVars).forEach((key)=>{
+            delete remoteVars[key];
+        });
+    });
+    test('returns an empty object if REMOTES is not set', ()=>{
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({});
+    });
+    test('parses asyncContainer from thenable object', ()=>{
+        const thenable = Promise.resolve({
+            get: ()=>true,
+            init: ()=>true
+        });
+        // @ts-ignore
+        remoteVars.thenable = thenable;
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            thenable: {
+                asyncContainer: thenable
+            }
+        });
+    });
+    test('parses asyncContainer from lazily executing function', ()=>{
+        const lazyFunction = ()=>Promise.resolve({
+                get: ()=>true,
+                init: ()=>true
+            });
+        // @ts-ignore
+        remoteVars.lazyFunction = lazyFunction;
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toHaveProperty('lazyFunction.asyncContainer');
+        expect(typeof remotes['lazyFunction'].asyncContainer).toBe('function');
+    });
+    test('parses delegate module', ()=>{
+        // @ts-ignore
+        Object.assign(remoteVars, {
+            delegate: 'internal some_module?remote=remoteGlobal@https://example.com/remoteEntry.js'
+        });
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            delegate: {
+                global: 'remoteGlobal',
+                url: 'https://example.com/remoteEntry.js'
+            }
+        });
+    });
+    test('parses global@url string', ()=>{
+        // @ts-ignore
+        remoteVars.remote = 'remoteGlobal@https://example.com/remoteEntry.js';
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            remote: {
+                global: 'remoteGlobal',
+                url: 'https://example.com/remoteEntry.js'
+            }
+        });
+    });
+    test('console.warn should be called for unsupported types', ()=>{
+        console.warn = jest.fn();
+        // @ts-ignore
+        remoteVars.unsupported = 42;
+        // Call the function that triggers the warning message
+        getRuntimeRemotes();
+        // Check that console.warn was called with the correct message
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][0]).toMatch(/Unable to retrieve runtime remotes/);
+        //@ts-ignore
+        console.log(console.warn.mock.calls[0][1].message);
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][1].message).toMatch(/runtime_remote/);
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][1].message).toMatch(/unsupported/);
+    });
+});
+

package/dist/esm/utils/importDelegateModule.test.mjs

@@ -0,0 +1,72 @@
+import { importDelegatedModule } from "./importDelegatedModule.mjs";
+import { loadScript } from "./pure.mjs";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+
+
+
+
+
+jest.mock('./pure');
+describe('importDelegatedModule', ()=>{
+    let mockLoadScript;
+    let mockRuntimeRemote;
+    beforeEach(()=>{
+        mockLoadScript = jest.fn();
+        mockRuntimeRemote = {
+            get: jest.fn(),
+            init: jest.fn()
+        };
+        loadScript.mockImplementation(()=>Promise.resolve(mockRuntimeRemote));
+    });
+    afterEach(()=>{
+        jest.resetAllMocks();
+    });
+    it('should successfully import a delegated module', async ()=>{
+        const result = await importDelegatedModule('test');
+        expect(loadScript).toHaveBeenCalledWith('test');
+        expect(result).toBe(mockRuntimeRemote);
+    });
+    it('should handle the case when globalThis is not defined', async ()=>{
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(loadScript).toHaveBeenCalledWith({
+            global: 'test'
+        });
+        expect(result).toBe(mockRuntimeRemote);
+    });
+    // Test case for when the module has a function property
+    it('should return a Promise that resolves to the result when the module is a Promise', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve('test'));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(await result.get('test')).toBe('test');
+        __webpack_require__.g.window = {}; // Reset window object
+    });
+    // Test case for when the module has a non-function property
+    xit('should define a non-function property on the result when the module has a non-function property', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve(()=>({
+                    testProp: 'test'
+                })));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        const getterFunction = await result.get('testProp');
+        const getter = getterFunction();
+        expect(getter).toBe('test');
+    });
+    // Test case for when the module is a Promise
+    it('should return a Promise that resolves to the result when the module is a Promise', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve('test'));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(result.get('test')).resolves.toBe('test');
+        __webpack_require__.g.window = {}; // Reset window object
+    });
+});
+

package/dist/esm/utils/importDelegatedModule.mjs

@@ -0,0 +1,72 @@
+import { loadScript } from "./pure.mjs";
+
+
+
+const importDelegatedModule = async (keyOrRuntimeRemoteItem)=>{
+    // @ts-ignore
+    return loadScript(keyOrRuntimeRemoteItem).then((asyncContainer)=>{
+        return asyncContainer;
+    }).then((asyncContainer)=>{
+        // most of this is only needed because of legacy promise based implementation
+        // can remove proxies once we remove promise based implementations
+        if (typeof window === 'undefined') {
+            if (!Object.hasOwnProperty.call(keyOrRuntimeRemoteItem, 'globalThis')) {
+                return asyncContainer;
+            }
+            // return asyncContainer;
+            //TODO: need to solve chunk flushing with delegated modules
+            return {
+                get: function(arg) {
+                    //@ts-ignore
+                    return asyncContainer.get(arg).then((f)=>{
+                        const m = f();
+                        const result = {
+                            __esModule: m.__esModule
+                        };
+                        for(const prop in m){
+                            if (typeof m[prop] === 'function') {
+                                Object.defineProperty(result, prop, {
+                                    get: function() {
+                                        return function() {
+                                            //@ts-ignore
+                                            if (globalThis.usedChunks) {
+                                                //@ts-ignore
+                                                globalThis.usedChunks.add(//@ts-ignore
+                                                `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                            }
+                                            //eslint-disable-next-line prefer-rest-params
+                                            return m[prop](...arguments);
+                                        };
+                                    },
+                                    enumerable: true
+                                });
+                            } else {
+                                Object.defineProperty(result, prop, {
+                                    get: ()=>{
+                                        //@ts-ignore
+                                        if (globalThis.usedChunks) {
+                                            //@ts-ignore
+                                            globalThis.usedChunks.add(//@ts-ignore
+                                            `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                        }
+                                        return m[prop];
+                                    },
+                                    enumerable: true
+                                });
+                            }
+                        }
+                        if (m.then) {
+                            return Promise.resolve(()=>result);
+                        }
+                        return ()=>result;
+                    });
+                },
+                init: asyncContainer.init
+            };
+        } else {
+            return asyncContainer;
+        }
+    });
+};
+
+export { importDelegatedModule };