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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 ScriptedAlchemy LLC (Zack Jackson)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# utils
+
+For warning： [`@module-federation/runtime`](https://module-federation.io/guide/basic/runtime/runtime.html) is recommended as a replacement
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build utils` to build the library.
+
+## Running unit tests
+
+Run `nx test utils` to execute the unit tests via [Jest](https://jestjs.io).
+
+## React utilities
+
+---
+
+`FederatedBoundary`
+
+A component wrapper that provides a fallback for safe imports if something were to fail when grabbing a module off of a remote host.
+
+This wrapper also exposes an optional property for a custom react error boundary component.
+
+Any extra props will be passed directly to the imported module.
+
+Usage looks something like this:
+
+```js
+import { FederationBoundary } from '@module-federation/utilities/src/utils/react';
+
+// defining dynamicImport and fallback outside the Component to keep the component identity
+// another alternative would be to use useMemo
+const dynamicImport = () => import('some_remote_host_name').then((m) => m.Component);
+const fallback = () => import('@npm/backup').then((m) => m.Component);
+
+const MyPage = () => {
+  return <FederationBoundary dynamicImporter={dynamicImport} fallback={fallback} customBoundary={CustomErrorBoundary} />;
+};
+```
+
+---
+
+`ImportRemote`
+
+A function which will enable dynamic imports of remotely exposed modules using the Module Federation plugin. It uses the method described in the official Webpack configuration under <a href="https://webpack.js.org/concepts/module-federation/#dynamic-remote-containers" target="_blank">Dynamic Remote Containers</a>.
+
+This function will allow you to provide a static url or an async method to retrieve a url from a configuration service.
+
+Usage looks something like this:
+
+```js
+import { importRemote } from '@module-federation/utilities';
+
+// --
+// If it's a regular js module:
+// --
+importRemote({
+  url: 'http://localhost:3001',
+  scope: 'Foo',
+  module: 'Bar',
+}).then(
+  (
+    {
+      /* list of Bar exports */
+    },
+  ) => {
+    // Use Bar exports
+  },
+);
+
+// --
+// If it's a ESM module (this is currently the default for NX):
+// --
+const Bar = lazy(() => importRemote({ url: 'http://localhost:3001', scope: 'Foo', module: 'Bar', esm: true }));
+
+return (
+  <Suspense fallback={<div>Loading Bar...</div>}>
+    <Bar />
+  </Suspense>
+);
+
+// --
+// If Bar is a React component you can use it with lazy and Suspense just like a dynamic import:
+// --
+const Bar = lazy(() => importRemote({ url: 'http://localhost:3001', scope: 'Foo', module: 'Bar' }));
+
+return (
+  <Suspense fallback={<div>Loading Bar...</div>}>
+    <Bar />
+  </Suspense>
+);
+```
+
+```js
+import { importRemote } from '@module-federation/utilities';
+
+// If it's a regular js module:
+importRemote({
+  url: () => MyAsyncMethod('remote_name'),
+  scope: 'Foo',
+  module: 'Bar',
+}).then(
+  (
+    {
+      /* list of Bar exports */
+    },
+  ) => {
+    // Use Bar exports
+  },
+);
+
+// If Bar is a React component you can use it with lazy and Suspense just like a dynamic import:
+const Bar = lazy(() =>
+  importRemote({
+    url: () => MyAsyncMethod('remote_name'),
+    scope: 'Foo',
+    module: 'Bar',
+  }),
+);
+
+return (
+  <Suspense fallback={<div>Loading Bar...</div>}>
+    <Bar />
+  </Suspense>
+);
+```
+
+```js
+// You can also combine importRemote and FederationBoundary to have a dynamic remote URL and a fallback when there is an error on the remote
+
+const dynamicImporter = () =>
+  importRemote({
+    url: 'http://localhost:3001',
+    scope: 'Foo',
+    module: 'Bar',
+  });
+const fallback = () => import('@npm/backup').then((m) => m.Component);
+
+const Bar = () => {
+  return <FederationBoundary dynamicImporter={dynamicImporter} fallback={fallback} />;
+};
+```
+
+Apart from **url**, **scope** and **module** you can also pass additional options to the **importRemote()** function:
+
+- **remoteEntryFileName**: The name of the remote entry file. Defaults to "remoteEntry.js".
+- **bustRemoteEntryCache**: Whether to add a cache busting query parameter to the remote entry file URL. Defaults to **true**. You can disable it if cachebusting is handled by the server.

package/dist/cjs/Logger.js

@@ -0,0 +1,63 @@
+"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, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// 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__);
+class Logger {
+    static getLogger() {
+        return this.loggerInstance;
+    }
+    static setLogger(logger) {
+        this.loggerInstance = logger || console;
+        return logger;
+    }
+}
+Logger.loggerInstance = console;
+
+__webpack_require__.d(__webpack_exports__, {
+  Logger: () => (Logger)
+});
+
+exports.Logger = __webpack_exports__.Logger;
+for(var __rspack_i in __webpack_exports__) {
+  if(["Logger"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/components/ErrorBoundary.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;
+})();
+;
+// 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, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// 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__, {
+  "default": () => (/* binding */ components_ErrorBoundary)
+});
+
+;// CONCATENATED MODULE: external "react"
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_namespaceObject);
+;// CONCATENATED MODULE: ./src/components/ErrorBoundary.tsx
+
+/**
+ * Generic error boundary component.
+ */ class ErrorBoundary extends (external_react_default()).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
+        };
+    }
+}
+/* export default */ const components_ErrorBoundary = (ErrorBoundary);
+
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__) {
+  if(["default"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/components/FederationBoundary.js

@@ -0,0 +1,103 @@
+"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, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// 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__, {
+  "default": () => (/* binding */ components_FederationBoundary)
+});
+
+;// CONCATENATED MODULE: external "react"
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/__webpack_require__.n(external_react_namespaceObject);
+;// CONCATENATED MODULE: external "./ErrorBoundary.js"
+const external_ErrorBoundary_js_namespaceObject = require("./ErrorBoundary.js");
+var external_ErrorBoundary_js_default = /*#__PURE__*/__webpack_require__.n(external_ErrorBoundary_js_namespaceObject);
+;// 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 = (external_ErrorBoundary_js_default()), ...rest })=>{
+    const ImportResult = (0,external_react_namespaceObject.useMemo)(()=>{
+        return /*#__PURE__*/ (0,external_react_namespaceObject.lazy)(()=>dynamicImporter().catch((e)=>{
+                console.error(e);
+                return fallback();
+            }).then((m)=>{
+                return {
+                    //@ts-ignore
+                    default: m.default || m
+                };
+            }));
+    }, [
+        dynamicImporter,
+        fallback
+    ]);
+    return /*#__PURE__*/ external_react_default().createElement(CustomBoundary, null, /*#__PURE__*/ external_react_default().createElement(ImportResult, rest));
+};
+/* export default */ const components_FederationBoundary = (FederationBoundary);
+
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__) {
+  if(["default"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,172 @@
+"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__ = ({
+160(module) {
+module.exports = require("./Logger.js");
+
+},
+704(module) {
+module.exports = require("./types/index.js");
+
+},
+37(module) {
+module.exports = require("./utils/common.js");
+
+},
+953(module) {
+module.exports = require("./utils/getRuntimeRemotes.js");
+
+},
+158(module) {
+module.exports = require("./utils/importDelegatedModule.js");
+
+},
+711(module) {
+module.exports = require("./utils/importRemote.js");
+
+},
+755(module) {
+module.exports = require("./utils/isEmpty.js");
+
+},
+576(module) {
+module.exports = require("./utils/pure.js");
+
+},
+
+});
+// 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/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, getters, values) => {
+	var define = (defs, kind) => {
+		for(var key in defs) {
+			if(__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) {
+				Object.defineProperty(exports, key, { enumerable: true, [kind]: defs[key] });
+			}
+		}
+	};
+	define(getters, "get");
+	define(values, "value");
+};
+})();
+// 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__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var _types__rspack_import_0 = __webpack_require__(704);
+/* import */ var _types__rspack_import_0_default = /*#__PURE__*/__webpack_require__.n(_types__rspack_import_0);
+
+/* reexport */ var __rspack_reexport = {};
+/* reexport */ for( const __rspack_import_key in _types__rspack_import_0) if(["getContainer","importRemote","isObjectEmpty","default","getRuntimeRemotes","loadScript","createRuntimeVariables","injectScript","getModule","Logger","importDelegatedModule","extractUrlAndGlobal"].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] =() => _types__rspack_import_0[__rspack_import_key]
+/* reexport */ __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+/* import */ var _utils_common__rspack_import_1 = __webpack_require__(37);
+/* import */ var _utils_common__rspack_import_1_default = /*#__PURE__*/__webpack_require__.n(_utils_common__rspack_import_1);
+/* import */ var _utils_isEmpty__rspack_import_2 = __webpack_require__(755);
+/* import */ var _utils_isEmpty__rspack_import_2_default = /*#__PURE__*/__webpack_require__.n(_utils_isEmpty__rspack_import_2);
+/* import */ var _utils_importRemote__rspack_import_3 = __webpack_require__(711);
+/* import */ var _utils_importRemote__rspack_import_3_default = /*#__PURE__*/__webpack_require__.n(_utils_importRemote__rspack_import_3);
+/* import */ var _Logger__rspack_import_4 = __webpack_require__(160);
+/* import */ var _Logger__rspack_import_4_default = /*#__PURE__*/__webpack_require__.n(_Logger__rspack_import_4);
+/* import */ var _utils_getRuntimeRemotes__rspack_import_5 = __webpack_require__(953);
+/* import */ var _utils_getRuntimeRemotes__rspack_import_5_default = /*#__PURE__*/__webpack_require__.n(_utils_getRuntimeRemotes__rspack_import_5);
+/* import */ var _utils_importDelegatedModule__rspack_import_6 = __webpack_require__(158);
+/* import */ var _utils_importDelegatedModule__rspack_import_6_default = /*#__PURE__*/__webpack_require__.n(_utils_importDelegatedModule__rspack_import_6);
+/* import */ var _utils_pure__rspack_import_7 = __webpack_require__(576);
+/* import */ var _utils_pure__rspack_import_7_default = /*#__PURE__*/__webpack_require__.n(_utils_pure__rspack_import_7);
+
+
+
+
+
+
+
+
+
+__webpack_require__.d(__webpack_exports__, {
+  Logger: () => (/* reexport safe */ _Logger__rspack_import_4.Logger),
+  createRuntimeVariables: () => (/* reexport safe */ _utils_common__rspack_import_1.createRuntimeVariables),
+  extractUrlAndGlobal: () => (/* reexport safe */ _utils_pure__rspack_import_7.extractUrlAndGlobal),
+  getContainer: () => (/* reexport safe */ _utils_common__rspack_import_1.getContainer),
+  getModule: () => (/* reexport safe */ _utils_common__rspack_import_1.getModule),
+  getRuntimeRemotes: () => (/* reexport safe */ _utils_getRuntimeRemotes__rspack_import_5.getRuntimeRemotes),
+  importDelegatedModule: () => (/* reexport safe */ _utils_importDelegatedModule__rspack_import_6.importDelegatedModule),
+  importRemote: () => (/* reexport safe */ _utils_importRemote__rspack_import_3.importRemote),
+  injectScript: () => (/* reexport safe */ _utils_common__rspack_import_1.injectScript),
+  isObjectEmpty: () => (/* reexport safe */ _utils_isEmpty__rspack_import_2.isObjectEmpty),
+  loadScript: () => (/* reexport safe */ _utils_pure__rspack_import_7.loadScript)
+});
+
+})();
+
+exports.Logger = __webpack_exports__.Logger;
+exports.createRuntimeVariables = __webpack_exports__.createRuntimeVariables;
+exports.extractUrlAndGlobal = __webpack_exports__.extractUrlAndGlobal;
+exports.getContainer = __webpack_exports__.getContainer;
+exports.getModule = __webpack_exports__.getModule;
+exports.getRuntimeRemotes = __webpack_exports__.getRuntimeRemotes;
+exports.importDelegatedModule = __webpack_exports__.importDelegatedModule;
+exports.importRemote = __webpack_exports__.importRemote;
+exports.injectScript = __webpack_exports__.injectScript;
+exports.isObjectEmpty = __webpack_exports__.isObjectEmpty;
+exports.loadScript = __webpack_exports__.loadScript;
+for(var __rspack_i in __webpack_exports__) {
+  if(["Logger","createRuntimeVariables","extractUrlAndGlobal","getContainer","getModule","getRuntimeRemotes","importDelegatedModule","importRemote","injectScript","isObjectEmpty","loadScript"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });