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

package/dist/cjs/plugins/DelegateModulesPlugin.js

@@ -0,0 +1,133 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+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 __rspack_default_export = (DelegateModulesPlugin);
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  "default": __rspack_default_export
+});
+
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__) {
+  if(["default"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/types/index.js

@@ -0,0 +1,31 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../../../../webpack/module.d.ts" />
+
+
+for(var __rspack_i in __webpack_exports__) {
+  exports[__rspack_i] = __webpack_exports__[__rspack_i];
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/common.js

@@ -0,0 +1,175 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  createRuntimeVariables: () => (/* binding */ createRuntimeVariables),
+  getContainer: () => (/* binding */ getContainer),
+  getModule: () => (/* binding */ getModule),
+  injectScript: () => (/* binding */ injectScript)
+});
+
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/common.ts
+/* 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 = (0,external_pure_js_namespaceObject.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;
+    }
+};
+
+exports.createRuntimeVariables = __webpack_exports__.createRuntimeVariables;
+exports.getContainer = __webpack_exports__.getContainer;
+exports.getModule = __webpack_exports__.getModule;
+exports.injectScript = __webpack_exports__.injectScript;
+for(var __rspack_i in __webpack_exports__) {
+  if(["createRuntimeVariables","getContainer","getModule","injectScript"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/getRuntimeRemotes.js

@@ -0,0 +1,104 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  getRuntimeRemotes: () => (/* binding */ getRuntimeRemotes)
+});
+
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/getRuntimeRemotes.ts
+
+const getRuntimeRemotes = ()=>{
+    try {
+        return Object.entries(external_pure_js_namespaceObject.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] = (0,external_pure_js_namespaceObject.extractUrlAndGlobal)(remoteSyntax);
+                        acc[key] = {
+                            global,
+                            url
+                        };
+                    }
+                }
+            } else if (typeof value === 'string') {
+                const [url, global] = (0,external_pure_js_namespaceObject.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 {};
+};
+
+exports.getRuntimeRemotes = __webpack_exports__.getRuntimeRemotes;
+for(var __rspack_i in __webpack_exports__) {
+  if(["getRuntimeRemotes"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/getRuntimeRemotes.test.js

@@ -0,0 +1,98 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+var __webpack_exports__ = {};
+
+;// CONCATENATED MODULE: external "./getRuntimeRemotes.js"
+const external_getRuntimeRemotes_js_namespaceObject = require("./getRuntimeRemotes.js");
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/getRuntimeRemotes.test.ts
+
+
+xdescribe('getRuntimeRemotes', ()=>{
+    afterEach(()=>{
+        Object.keys(external_pure_js_namespaceObject.remoteVars).forEach((key)=>{
+            delete external_pure_js_namespaceObject.remoteVars[key];
+        });
+    });
+    test('returns an empty object if REMOTES is not set', ()=>{
+        const remotes = (0,external_getRuntimeRemotes_js_namespaceObject.getRuntimeRemotes)();
+        expect(remotes).toEqual({});
+    });
+    test('parses asyncContainer from thenable object', ()=>{
+        const thenable = Promise.resolve({
+            get: ()=>true,
+            init: ()=>true
+        });
+        // @ts-ignore
+        external_pure_js_namespaceObject.remoteVars.thenable = thenable;
+        const remotes = (0,external_getRuntimeRemotes_js_namespaceObject.getRuntimeRemotes)();
+        expect(remotes).toEqual({
+            thenable: {
+                asyncContainer: thenable
+            }
+        });
+    });
+    test('parses asyncContainer from lazily executing function', ()=>{
+        const lazyFunction = ()=>Promise.resolve({
+                get: ()=>true,
+                init: ()=>true
+            });
+        // @ts-ignore
+        external_pure_js_namespaceObject.remoteVars.lazyFunction = lazyFunction;
+        const remotes = (0,external_getRuntimeRemotes_js_namespaceObject.getRuntimeRemotes)();
+        expect(remotes).toHaveProperty('lazyFunction.asyncContainer');
+        expect(typeof remotes['lazyFunction'].asyncContainer).toBe('function');
+    });
+    test('parses delegate module', ()=>{
+        // @ts-ignore
+        Object.assign(external_pure_js_namespaceObject.remoteVars, {
+            delegate: 'internal some_module?remote=remoteGlobal@https://example.com/remoteEntry.js'
+        });
+        const remotes = (0,external_getRuntimeRemotes_js_namespaceObject.getRuntimeRemotes)();
+        expect(remotes).toEqual({
+            delegate: {
+                global: 'remoteGlobal',
+                url: 'https://example.com/remoteEntry.js'
+            }
+        });
+    });
+    test('parses global@url string', ()=>{
+        // @ts-ignore
+        external_pure_js_namespaceObject.remoteVars.remote = 'remoteGlobal@https://example.com/remoteEntry.js';
+        const remotes = (0,external_getRuntimeRemotes_js_namespaceObject.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
+        external_pure_js_namespaceObject.remoteVars.unsupported = 42;
+        // Call the function that triggers the warning message
+        (0,external_getRuntimeRemotes_js_namespaceObject.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/);
+    });
+});
+
+for(var __rspack_i in __webpack_exports__) {
+  exports[__rspack_i] = __webpack_exports__[__rspack_i];
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/importDelegateModule.test.js

@@ -0,0 +1,99 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// 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;
+	}
+})();
+})();
+var __webpack_exports__ = {};
+
+;// CONCATENATED MODULE: external "./importDelegatedModule.js"
+const external_importDelegatedModule_js_namespaceObject = require("./importDelegatedModule.js");
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/importDelegateModule.test.ts
+
+
+jest.mock('./pure');
+describe('importDelegatedModule', ()=>{
+    let mockLoadScript;
+    let mockRuntimeRemote;
+    beforeEach(()=>{
+        mockLoadScript = jest.fn();
+        mockRuntimeRemote = {
+            get: jest.fn(),
+            init: jest.fn()
+        };
+        external_pure_js_namespaceObject.loadScript.mockImplementation(()=>Promise.resolve(mockRuntimeRemote));
+    });
+    afterEach(()=>{
+        jest.resetAllMocks();
+    });
+    it('should successfully import a delegated module', async ()=>{
+        const result = await (0,external_importDelegatedModule_js_namespaceObject.importDelegatedModule)('test');
+        expect(external_pure_js_namespaceObject.loadScript).toHaveBeenCalledWith('test');
+        expect(result).toBe(mockRuntimeRemote);
+    });
+    it('should handle the case when globalThis is not defined', async ()=>{
+        const result = await (0,external_importDelegatedModule_js_namespaceObject.importDelegatedModule)({
+            global: 'test'
+        });
+        expect(external_pure_js_namespaceObject.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 (0,external_importDelegatedModule_js_namespaceObject.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 (0,external_importDelegatedModule_js_namespaceObject.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 (0,external_importDelegatedModule_js_namespaceObject.importDelegatedModule)({
+            global: 'test'
+        });
+        expect(result.get('test')).resolves.toBe('test');
+        __webpack_require__.g.window = {}; // Reset window object
+    });
+});
+
+for(var __rspack_i in __webpack_exports__) {
+  exports[__rspack_i] = __webpack_exports__[__rspack_i];
+}
+Object.defineProperty(exports, '__esModule', { value: true });