@module-federation/utilities 3.1.82 → 3.1.84

package/dist/cjs/utils/common.js

@@ -0,0 +1,173 @@
+"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, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// 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__, {
+  injectScript: () => (/* binding */ injectScript),
+  getContainer: () => (/* binding */ getContainer),
+  createRuntimeVariables: () => (/* binding */ createRuntimeVariables),
+  getModule: () => (/* binding */ getModule)
+});
+
+;// 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 === null || container === void 0 ? void 0 : 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 __webpack_i__ in __webpack_exports__) {
+  if(["createRuntimeVariables","getContainer","getModule","injectScript"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/getRuntimeRemotes.js

@@ -0,0 +1,102 @@
+"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, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// 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 __webpack_i__ in __webpack_exports__) {
+  if(["getRuntimeRemotes"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_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 __webpack_i__ in __webpack_exports__) {
+  exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+}
+Object.defineProperty(exports, '__esModule', { value: true });

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

@@ -0,0 +1,101 @@
+"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 __webpack_i__ in __webpack_exports__) {
+  exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/importDelegatedModule.js

@@ -0,0 +1,124 @@
+"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, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// 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__, {
+  importDelegatedModule: () => (/* binding */ importDelegatedModule)
+});
+
+;// CONCATENATED MODULE: external "./pure.js"
+const external_pure_js_namespaceObject = require("./pure.js");
+;// CONCATENATED MODULE: ./src/utils/importDelegatedModule.ts
+
+const importDelegatedModule = async (keyOrRuntimeRemoteItem)=>{
+    // @ts-ignore
+    return (0,external_pure_js_namespaceObject.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;
+        }
+    });
+};
+
+exports.importDelegatedModule = __webpack_exports__.importDelegatedModule;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["importDelegatedModule"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });