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

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/dist/types/Logger.d.ts

@@ -0,0 +1,7 @@
+import { Compilation } from 'webpack';
+export type LoggerInstance = Compilation['logger'] | Console;
+export declare class Logger {
+    private static loggerInstance;
+    static getLogger(): LoggerInstance;
+    static setLogger(logger: Compilation['logger']): LoggerInstance;
+}

package/dist/types/components/ErrorBoundary.d.ts

@@ -0,0 +1,19 @@
+import React, { type ErrorInfo } from 'react';
+export interface ErrorBoundaryProps {
+    children: React.ReactNode;
+}
+export interface ErrorBoundaryState {
+    hasError: boolean;
+}
+/**
+ * Generic error boundary component.
+ */
+declare class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export default ErrorBoundary;

package/dist/types/components/FederationBoundary.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { ComponentClass, ComponentType, PropsWithChildren } from 'react';
+export interface FederationBoundaryProps {
+    dynamicImporter: () => Promise<ComponentType<any>>;
+    fallback?: () => Promise<ComponentType<any>>;
+    customBoundary?: ComponentClass<PropsWithChildren<any>>;
+    [props: string]: any;
+}
+/**
+ * Wrapper around dynamic import.
+ * Adds error boundaries and fallback options.
+ */
+declare const FederationBoundary: React.FC<FederationBoundaryProps>;
+export default FederationBoundary;

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export type { ImportRemoteOptions } from './utils/importRemote';
+export type { LoggerInstance } from './Logger';
+export { createRuntimeVariables, getContainer, injectScript, getModule, } from './utils/common';
+export { isObjectEmpty } from './utils/isEmpty';
+export { importRemote } from './utils/importRemote';
+export { Logger } from './Logger';
+export { getRuntimeRemotes } from './utils/getRuntimeRemotes';
+export { importDelegatedModule } from './utils/importDelegatedModule';
+export { extractUrlAndGlobal, loadScript } from './utils/pure';

package/dist/types/plugins/DelegateModulesPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { Compiler, Compilation, Chunk, NormalModule } from 'webpack';
+declare class DelegateModulesPlugin {
+    options: {
+        debug: boolean;
+        [key: string]: any;
+    };
+    _delegateModules: Map<string, NormalModule>;
+    constructor(options: {
+        debug?: boolean;
+        [key: string]: any;
+    });
+    getChunkByName(chunks: Iterable<Chunk>, name: string): Chunk | undefined;
+    private addDelegatesToChunks;
+    private addModuleAndDependenciesToChunk;
+    removeDelegatesNonRuntimeChunks(compilation: Compilation, chunks: Iterable<Chunk>): void;
+    apply(compiler: Compiler): void;
+}
+export default DelegateModulesPlugin;

package/dist/types/types/index.d.ts

@@ -0,0 +1,76 @@
+import type { moduleFederationPlugin } from '@module-federation/sdk';
+import type { WebpackOptionsNormalized } from 'webpack';
+export type ModuleFederationPluginOptions = moduleFederationPlugin.ModuleFederationPluginOptions;
+export type WebpackRequire = {
+    l: (url: string | undefined, cb: (event: any) => void, id: string | number) => Record<string, unknown>;
+};
+export type WebpackShareScopes = Record<string, Record<string, {
+    loaded?: 1;
+    get: () => Promise<unknown>;
+    from: string;
+    eager: boolean;
+}>> & {
+    default?: string;
+};
+export type GlobalScopeType = {
+    [K: string]: any;
+    _config?: Record<string | number, any>;
+    _medusa?: Record<string, any> | undefined;
+    remoteLoading?: Record<string, Promise<AsyncContainer>>;
+};
+export declare const __webpack_init_sharing__: (parameter: string) => Promise<void>;
+export interface NextFederationPluginExtraOptions {
+    enableImageLoaderFix?: boolean;
+    enableUrlLoaderFix?: boolean;
+    exposePages?: boolean;
+    skipSharingNextInternals?: boolean;
+    automaticPageStitching?: boolean;
+    debug?: boolean;
+}
+export interface NextFederationPluginOptions extends ModuleFederationPluginOptions {
+    extraOptions: NextFederationPluginExtraOptions;
+}
+export type Shared = ModuleFederationPluginOptions['shared'];
+export type Remotes = ModuleFederationPluginOptions['remotes'];
+export type SharedObject = Extract<Shared, ModuleFederationPluginOptions>;
+export type SharedConfig = Extract<SharedObject[keyof SharedObject], {
+    eager?: boolean;
+}>;
+export type ExternalsType = Required<ModuleFederationPluginOptions['remoteType']>;
+type ModulePath = string;
+export type WebpackRemoteContainer = {
+    __initialized?: boolean;
+    get(modulePath: ModulePath): () => any;
+    init: (obj?: typeof __webpack_share_scopes__) => void;
+};
+export type AsyncContainer = Promise<WebpackRemoteContainer>;
+export type RemoteData = {
+    global: string;
+    url: string;
+    uniqueKey?: string;
+};
+export type RuntimeRemote = Partial<RemoteData> & {
+    asyncContainer?: AsyncContainer;
+    global?: string;
+    url?: string;
+};
+export type RuntimeRemotesMap = Record<string, RuntimeRemote>;
+type Module = WebpackOptionsNormalized['module'];
+type Rules = Module['rules'];
+export type RuleSetRuleUnion = Rules[0];
+type RuleSetRule = Extract<RuleSetRuleUnion, {
+    loader?: string;
+}>;
+export type Loader = Extract<RuleSetRule['use'], {
+    loader?: string;
+}>;
+export type EventTypes = 'loadStart' | 'loadComplete' | 'loadError';
+type NextRoute = string;
+export type PageMap = Record<NextRoute, ModulePath>;
+export type GetModuleOptions = {
+    modulePath: string;
+    exportName?: string;
+    remoteContainer: string | RemoteData;
+};
+export type RemoteVars = Record<string, Promise<WebpackRemoteContainer> | string | (() => Promise<WebpackRemoteContainer>)>;
+export {};

package/dist/types/utils/common.d.ts

@@ -0,0 +1,31 @@
+import type { GetModuleOptions, RemoteData, Remotes, RuntimeRemote, WebpackRemoteContainer } from '../types';
+/**
+ * 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
+ */
+export declare const injectScript: (keyOrRuntimeRemoteItem: string | RuntimeRemote) => Promise<WebpackRemoteContainer>;
+/**
+ * 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.
+ */
+export declare const createRuntimeVariables: (remotes: Remotes) => Record<string, string>;
+/**
+ * Returns initialized webpack RemoteContainer.
+ * If its' script does not loaded - then load & init it firstly.
+ */
+export declare const getContainer: (remoteContainer: string | RemoteData) => Promise<WebpackRemoteContainer | undefined>;
+/**
+ * Return remote module from container.
+ * If you provide `exportName` it automatically return exact property value from module.
+ *
+ * @example
+ *   remote.getModule('./pages/index', 'default')
+ */
+export declare const getModule: ({ remoteContainer, modulePath, exportName, }: GetModuleOptions) => Promise<any>;

package/dist/types/utils/getRuntimeRemotes.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeRemotesMap } from '../types';
+export declare const getRuntimeRemotes: () => RuntimeRemotesMap;

package/dist/types/utils/importDelegatedModule.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeRemote } from '../types';
+export declare const importDelegatedModule: (keyOrRuntimeRemoteItem: string | RuntimeRemote) => Promise<any>;

package/dist/types/utils/importRemote.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Type definition for RemoteUrl
+ * @typedef {string | function} RemoteUrl
+ */
+type RemoteUrl = string | (() => Promise<string>);
+/**
+ * Interface for ImportRemoteOptions
+ * @interface
+ * @property {RemoteUrl} url - The url of the remote module
+ * @property {string} scope - The scope of the remote module
+ * @property {string} module - The module to import
+ * @property {string} [remoteEntryFileName] - The filename of the remote entry
+ * @property {boolean} [bustRemoteEntryCache] - Flag to bust the remote entry cache
+ */
+export interface ImportRemoteOptions {
+    url: RemoteUrl;
+    scope: string;
+    module: string;
+    remoteEntryFileName?: string;
+    bustRemoteEntryCache?: boolean;
+    esm?: boolean;
+}
+/**
+ * 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
+ */
+export declare const importRemote: <T>({ url, scope, module, remoteEntryFileName, bustRemoteEntryCache, esm, }: ImportRemoteOptions) => Promise<T>;
+export {};

package/dist/types/utils/isEmpty.d.ts

@@ -0,0 +1 @@
+export declare const isObjectEmpty: <T extends object>(obj: T) => boolean;

package/dist/types/utils/pure.d.ts

@@ -0,0 +1,5 @@
+import { RemoteVars, RuntimeRemote, RuntimeRemotesMap } from '../types';
+export declare const remoteVars: RemoteVars;
+export declare const extractUrlAndGlobal: (urlAndGlobal: string) => [string, string];
+export declare const loadScript: (keyOrRuntimeRemoteItem: string | RuntimeRemote) => any;
+export declare const getRuntimeRemotes: () => RuntimeRemotesMap;

package/dist/types/utils/react.d.ts

@@ -0,0 +1 @@
+export { default as FederationBoundary } from '../components/FederationBoundary';

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@module-federation/utilities",
+  "version": "0.0.0-chore-bump-node-22-20260710161714",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/utilities"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.11",
+    "react": "18.3.1",
+    "rsbuild-plugin-publint": "^0.2.1"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "0.0.0-chore-bump-node-22-20260710161714"
+  },
+  "peerDependencies": {
+    "react": "^16 || ^17 || ^18",
+    "react-dom": "^16 || ^17 || ^18",
+    "webpack": "^5.40.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./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"
+  }
+}