@module-federation/utilities 0.0.0-perf-devtools-20260107043700 → 0.0.0-perf-website-code-usage-20260914033703

package/dist/esm/utils/importRemote.mjs

@@ -0,0 +1,105 @@
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+
+/**
+ * Constant for remote entry file
+ * @constant {string}
+ */ const REMOTE_ENTRY_FILE = 'remoteEntry.js';
+/**
+ * Function to load remote
+ * @function
+ * @param {ImportRemoteOptions['url']} url - The url of the remote module
+ * @param {ImportRemoteOptions['scope']} scope - The scope of the remote module
+ * @param {ImportRemoteOptions['bustRemoteEntryCache']} bustRemoteEntryCache - Flag to bust the remote entry cache
+ * @returns {Promise<void>} A promise that resolves when the remote is loaded
+ */ const loadRemote = (url, scope, bustRemoteEntryCache)=>new Promise((resolve, reject)=>{
+        const timestamp = bustRemoteEntryCache ? `?t=${new Date().getTime()}` : '';
+        const webpackRequire = __webpack_require__;
+        webpackRequire.l(`${url}${timestamp}`, (event)=>{
+            if (event?.type === 'load') {
+                // Script loaded successfully:
+                return resolve();
+            }
+            const realSrc = event?.target?.src;
+            const error = new Error();
+            error.message = 'Loading script failed.\n(missing: ' + realSrc + ')';
+            error.name = 'ScriptExternalLoadError';
+            reject(error);
+        }, scope);
+    });
+const loadEsmRemote = async (url, scope)=>{
+    const module = await import(/* webpackIgnore: true */ url);
+    if (!module) {
+        throw new Error(`Unable to load requested remote from ${url} with scope ${scope}`);
+    }
+    window[scope] = {
+        ...module,
+        __initializing: false,
+        __initialized: false
+    };
+};
+/**
+ * Function to initialize sharing
+ * @async
+ * @function
+ */ const initSharing = async ()=>{
+    const webpackShareScopes = __webpack_require__.S;
+    if (!webpackShareScopes?.default) {
+        await __webpack_require__.I('default');
+    }
+};
+/**
+ * Function to initialize container
+ * @async
+ * @function
+ * @param {WebpackRemoteContainer} containerScope - The container scope
+ */ const initContainer = async (containerScope)=>{
+    try {
+        const webpackShareScopes = __webpack_require__.S;
+        if (!containerScope.__initialized && !containerScope.__initializing) {
+            containerScope.__initializing = true;
+            await containerScope.init(webpackShareScopes.default);
+            containerScope.__initialized = true;
+            delete containerScope.__initializing;
+        }
+    } catch (error) {
+        console.error(error);
+    }
+};
+/**
+ * Function to import remote
+ * @async
+ * @function
+ * @param {ImportRemoteOptions} options - The options for importing the remote
+ * @returns {Promise<T>} A promise that resolves with the imported module
+ */ const importRemote = async ({ url, scope, module, remoteEntryFileName = REMOTE_ENTRY_FILE, bustRemoteEntryCache = true, esm = false })=>{
+    const remoteScope = scope;
+    if (!window[remoteScope]) {
+        let remoteUrl = '';
+        if (typeof url === 'string') {
+            remoteUrl = url;
+        } else {
+            remoteUrl = await url();
+        }
+        const remoteUrlWithEntryFile = `${remoteUrl}/${remoteEntryFileName}`;
+        const asyncContainer = !esm ? loadRemote(remoteUrlWithEntryFile, scope, bustRemoteEntryCache) : loadEsmRemote(remoteUrlWithEntryFile, scope);
+        // Load the remote and initialize the share scope if it's empty
+        await Promise.all([
+            asyncContainer,
+            initSharing()
+        ]);
+        if (!window[remoteScope]) {
+            throw new Error(`Remote loaded successfully but ${scope} could not be found! Verify that the name is correct in the Webpack configuration!`);
+        }
+        // Initialize the container to get shared modules and get the module factory:
+        const [, moduleFactory] = await Promise.all([
+            initContainer(window[remoteScope]),
+            window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`)
+        ]);
+        return moduleFactory();
+    } else {
+        const moduleFactory = await window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`);
+        return moduleFactory();
+    }
+};
+
+export { importRemote };

package/dist/esm/utils/isEmpty.mjs

@@ -0,0 +1,8 @@
+const isObjectEmpty = (obj)=>{
+    for(const x in obj){
+        return false;
+    }
+    return true;
+};
+
+export { isObjectEmpty };

package/dist/esm/utils/pure.mjs

@@ -0,0 +1,138 @@
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+
+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,4 @@
+
+
+
+export { default as FederationBoundary } from "../components/FederationBoundary.mjs";

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@module-federation/utilities",
-  "version": "0.0.0-perf-devtools-20260107043700",
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.esm.js",
-  "types": "./dist/index.d.ts",
+  "version": "0.0.0-perf-website-code-usage-20260914033703",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -18,11 +18,12 @@
     "directory": "packages/utilities"
   },
   "devDependencies": {
+    "@types/react": "^18.3.11",
     "react": "18.3.1",
-    "@types/react": "^18.3.11"
+    "rsbuild-plugin-publint": "^0.2.1"
   },
   "dependencies": {
-    "@module-federation/sdk": "0.0.0-perf-devtools-20260107043700"
+    "@module-federation/sdk": "0.0.0-perf-website-code-usage-20260914033703"
   },
   "peerDependencies": {
     "react": "^16 || ^17 || ^18",
@@ -42,20 +43,26 @@
   },
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.cjs.js"
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
     },
     "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
+        "./dist/types/index.d.ts"
       ],
       "type": [
         "./dist/type.d.ts"
       ]
     }
+  },
+  "scripts": {
+    "build": "rslib build",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.ts\"",
+    "test": "pnpm exec jest --config jest.config.ts --passWithNoTests",
+    "pre-release": "pnpm run test && pnpm run build"
   }
 }