@module-federation/utilities 3.1.83 → 3.1.84

package/dist/cjs/utils/importRemote.js

@@ -0,0 +1,174 @@
+"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_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;
+
+}
+
+/************************************************************************/
+// 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__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  importRemote: () => (importRemote)
+});
+/**
+ * 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)=>{
+            var _event_target;
+            if ((event === null || event === void 0 ? void 0 : event.type) === 'load') {
+                // Script loaded successfully:
+                return resolve();
+            }
+            const realSrc = event === null || event === void 0 ? void 0 : (_event_target = event.target) === null || _event_target === void 0 ? void 0 : _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 === null || webpackShareScopes === void 0 ? void 0 : 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();
+    }
+};
+
+exports.importRemote = __webpack_exports__.importRemote;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["importRemote"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/isEmpty.js

@@ -0,0 +1,56 @@
+"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__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  isObjectEmpty: () => (isObjectEmpty)
+});
+const isObjectEmpty = (obj)=>{
+    for(const x in obj){
+        return false;
+    }
+    return true;
+};
+
+exports.isObjectEmpty = __webpack_exports__.isObjectEmpty;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["isObjectEmpty"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/pure.js

@@ -0,0 +1,212 @@
+"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_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;
+
+}
+
+/************************************************************************/
+// 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__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+  extractUrlAndGlobal: () => (extractUrlAndGlobal),
+  getRuntimeRemotes: () => (getRuntimeRemotes),
+  loadScript: () => (loadScript),
+  remoteVars: () => (remoteVars)
+});
+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;
+    }, {});
+};
+
+exports.extractUrlAndGlobal = __webpack_exports__.extractUrlAndGlobal;
+exports.getRuntimeRemotes = __webpack_exports__.getRuntimeRemotes;
+exports.loadScript = __webpack_exports__.loadScript;
+exports.remoteVars = __webpack_exports__.remoteVars;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["extractUrlAndGlobal","getRuntimeRemotes","loadScript","remoteVars"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/utils/react.js

@@ -0,0 +1,71 @@
+"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/compat_get_default_export
+(() => {
+// getDefaultExport function for compatibility with non-ESM modules
+__webpack_require__.n = (module) => {
+	var getter = module && module.__esModule ?
+		() => (module['default']) :
+		() => (module);
+	__webpack_require__.d(getter, { a: getter });
+	return getter;
+};
+
+})();
+// 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__, {
+  FederationBoundary: () => (/* reexport */ (FederationBoundary_js_default()))
+});
+
+;// CONCATENATED MODULE: external "../components/FederationBoundary.js"
+const FederationBoundary_js_namespaceObject = require("../components/FederationBoundary.js");
+var FederationBoundary_js_default = /*#__PURE__*/__webpack_require__.n(FederationBoundary_js_namespaceObject);
+;// CONCATENATED MODULE: ./src/utils/react.tsx
+
+
+exports.FederationBoundary = __webpack_exports__.FederationBoundary;
+for(var __webpack_i__ in __webpack_exports__) {
+  if(["FederationBoundary"].indexOf(__webpack_i__) === -1) {
+    exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/esm/Logger.mjs

@@ -0,0 +1,14 @@
+
+;// CONCATENATED MODULE: ./src/Logger.ts
+class Logger {
+    static getLogger() {
+        return this.loggerInstance;
+    }
+    static setLogger(logger) {
+        this.loggerInstance = logger || console;
+        return logger;
+    }
+}
+Logger.loggerInstance = console;
+
+export { Logger };

package/dist/esm/components/ErrorBoundary.mjs

@@ -0,0 +1,33 @@
+import react from "react";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/components/ErrorBoundary.tsx
+
+/**
+ * Generic error boundary component.
+ */ class ErrorBoundary extends react.Component {
+    static getDerivedStateFromError() {
+        return {
+            hasError: true
+        };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error(error, errorInfo);
+    }
+    render() {
+        if (this.state.hasError) {
+            return 'An error has occurred.';
+        }
+        return this.props.children;
+    }
+    constructor(props){
+        super(props);
+        this.state = {
+            hasError: false
+        };
+    }
+}
+/* ESM default export */ const components_ErrorBoundary = (ErrorBoundary);
+
+export { components_ErrorBoundary as default };

package/dist/esm/components/FederationBoundary.mjs

@@ -0,0 +1,38 @@
+import react, { lazy, useMemo } from "react";
+import ErrorBoundary from "./ErrorBoundary.mjs";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./ErrorBoundary.mjs"
+
+;// CONCATENATED MODULE: ./src/components/FederationBoundary.tsx
+
+
+/**
+ * A fallback component that renders nothing.
+ */ const FallbackComponent = ()=>{
+    return null;
+};
+/**
+ * Wrapper around dynamic import.
+ * Adds error boundaries and fallback options.
+ */ const FederationBoundary = ({ dynamicImporter, fallback = ()=>Promise.resolve(FallbackComponent), customBoundary: CustomBoundary = ErrorBoundary, ...rest })=>{
+    const ImportResult = useMemo(()=>{
+        return /*#__PURE__*/ lazy(()=>dynamicImporter().catch((e)=>{
+                console.error(e);
+                return fallback();
+            }).then((m)=>{
+                return {
+                    //@ts-ignore
+                    default: m.default || m
+                };
+            }));
+    }, [
+        dynamicImporter,
+        fallback
+    ]);
+    return /*#__PURE__*/ react.createElement(CustomBoundary, null, /*#__PURE__*/ react.createElement(ImportResult, rest));
+};
+/* ESM default export */ const components_FederationBoundary = (FederationBoundary);
+
+export { components_FederationBoundary as default };

package/dist/esm/index.mjs

@@ -0,0 +1,34 @@
+import { createRuntimeVariables, getContainer, getModule, injectScript } from "./utils/common.mjs";
+import { isObjectEmpty } from "./utils/isEmpty.mjs";
+import { importRemote } from "./utils/importRemote.mjs";
+import { Logger } from "./Logger.mjs";
+import { getRuntimeRemotes } from "./utils/getRuntimeRemotes.mjs";
+import { importDelegatedModule } from "./utils/importDelegatedModule.mjs";
+import { extractUrlAndGlobal, loadScript } from "./utils/pure.mjs";
+export * from "./types/index.mjs";
+
+;// CONCATENATED MODULE: external "./utils/common.mjs"
+
+;// CONCATENATED MODULE: external "./utils/isEmpty.mjs"
+
+;// CONCATENATED MODULE: external "./utils/importRemote.mjs"
+
+;// CONCATENATED MODULE: external "./Logger.mjs"
+
+;// CONCATENATED MODULE: external "./utils/getRuntimeRemotes.mjs"
+
+;// CONCATENATED MODULE: external "./utils/importDelegatedModule.mjs"
+
+;// CONCATENATED MODULE: external "./utils/pure.mjs"
+
+;// CONCATENATED MODULE: ./src/index.ts
+
+
+
+
+
+
+
+
+
+export { Logger, createRuntimeVariables, extractUrlAndGlobal, getContainer, getModule, getRuntimeRemotes, importDelegatedModule, importRemote, injectScript, isObjectEmpty, loadScript };