@module-federation/utilities 3.1.82 → 3.1.84

package/dist/esm/utils/pure.mjs

@@ -0,0 +1,164 @@
+var __webpack_modules__ = ({});
+/************************************************************************/
+// 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;
+
+}
+
+/************************************************************************/
+
+;// CONCATENATED MODULE: ./src/utils/pure.ts
+const pure = typeof process !== 'undefined' ? process.env['REMOTES'] || {} : {};
+const remoteVars = pure;
+const extractUrlAndGlobal = (urlAndGlobal)=>{
+    const index = urlAndGlobal.indexOf('@');
+    if (index <= 0 || index === urlAndGlobal.length - 1) {
+        throw new Error(`Invalid request "${urlAndGlobal}"`);
+    }
+    return [
+        urlAndGlobal.substring(index + 1),
+        urlAndGlobal.substring(0, index)
+    ];
+};
+const loadScript = (keyOrRuntimeRemoteItem)=>{
+    const runtimeRemotes = getRuntimeRemotes();
+    // 1) Load remote container if needed
+    let asyncContainer;
+    const reference = typeof keyOrRuntimeRemoteItem === 'string' ? runtimeRemotes[keyOrRuntimeRemoteItem] : keyOrRuntimeRemoteItem;
+    if (reference.asyncContainer) {
+        asyncContainer = typeof reference.asyncContainer.then === 'function' ? reference.asyncContainer : reference.asyncContainer();
+    } else {
+        // This casting is just to satisfy typescript,
+        // In reality remoteGlobal will always be a string;
+        const remoteGlobal = reference.global;
+        // Check if theres an override for container key if not use remote global
+        const containerKey = reference.uniqueKey ? reference.uniqueKey : remoteGlobal;
+        const __webpack_error__ = new Error();
+        // @ts-ignore
+        const globalScope = // @ts-ignore
+        typeof window !== 'undefined' ? window : globalThis.__remote_scope__;
+        if (typeof window === 'undefined') {
+            //@ts-ignore
+            globalScope['_config'][containerKey] = reference.url;
+        } else {
+            // to match promise template system, can be removed once promise template is gone
+            //@ts-ignore
+            if (!globalScope['remoteLoading']) {
+                //@ts-ignore
+                globalScope['remoteLoading'] = {};
+            }
+            //@ts-ignore
+            if (globalScope['remoteLoading'][containerKey]) {
+                //@ts-ignore
+                return globalScope['remoteLoading'][containerKey];
+            }
+        }
+        // @ts-ignore
+        asyncContainer = new Promise(function(resolve, reject) {
+            function resolveRemoteGlobal() {
+                //@ts-ignore
+                const asyncContainer = globalScope[remoteGlobal];
+                return resolve(asyncContainer);
+            }
+            //@ts-ignore
+            if (typeof globalScope[remoteGlobal] !== 'undefined') {
+                return resolveRemoteGlobal();
+            }
+            __webpack_require__.l(reference.url, function(event) {
+                //@ts-ignore
+                if (typeof globalScope[remoteGlobal] !== 'undefined') {
+                    return resolveRemoteGlobal();
+                }
+                const errorType = event && (event.type === 'load' ? 'missing' : event.type);
+                const realSrc = event && event.target && event.target.src;
+                __webpack_error__.message = 'Loading script failed.\n(' + errorType + ': ' + realSrc + ' or global var ' + remoteGlobal + ')';
+                __webpack_error__.name = 'ScriptExternalLoadError';
+                __webpack_error__.type = errorType;
+                __webpack_error__.request = realSrc;
+                reject(__webpack_error__);
+            }, containerKey);
+        }).catch(function(err) {
+            console.error('container is offline, returning fake remote');
+            console.error(err);
+            return {
+                fake: true,
+                // @ts-ignore
+                get: (arg)=>{
+                    console.warn('faking', arg, 'module on, its offline');
+                    return Promise.resolve(()=>{
+                        return {
+                            __esModule: true,
+                            default: ()=>{
+                                return null;
+                            }
+                        };
+                    });
+                },
+                //eslint-disable-next-line
+                init: ()=>{}
+            };
+        });
+        if (typeof window !== 'undefined') {
+            //@ts-ignore
+            globalScope['remoteLoading'][containerKey] = asyncContainer;
+        }
+    }
+    return asyncContainer;
+};
+const getRuntimeRemotes = ()=>{
+    return Object.entries(remoteVars).reduce((acc, [key, value])=>{
+        if (typeof value === 'object' && typeof value.then === 'function') {
+            acc[key] = {
+                asyncContainer: value
+            };
+        } else if (typeof value === 'function') {
+            acc[key] = {
+                asyncContainer: Promise.resolve(value())
+            };
+        } else if (typeof value === 'string') {
+            if (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 {
+                const [url, global] = extractUrlAndGlobal(value);
+                acc[key] = {
+                    global,
+                    url
+                };
+            }
+        } else {
+            console.warn('remotes process', process.env['REMOTES']);
+            throw new Error(`[mf] Invalid value received for runtime_remote "${key}"`);
+        }
+        return acc;
+    }, {});
+};
+
+export { extractUrlAndGlobal, getRuntimeRemotes, loadScript, remoteVars };

package/dist/esm/utils/react.mjs

@@ -0,0 +1,8 @@
+import FederationBoundary from "../components/FederationBoundary.mjs";
+
+;// CONCATENATED MODULE: external "../components/FederationBoundary.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/react.tsx
+
+
+export { FederationBoundary };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@module-federation/utilities",
-  "version": "3.1.82",
+  "version": "3.1.84",
   "main": "./dist/index.cjs.js",
   "module": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",
@@ -22,7 +22,7 @@
     "@types/react": "^18.3.11"
   },
   "dependencies": {
-    "@module-federation/sdk": "0.24.1"
+    "@module-federation/sdk": "2.0.1"
   },
   "peerDependencies": {
     "react": "^16 || ^17 || ^18",