@kaena1/mm-ui-shared-utils 1.25.0-f-poc-EC-3301.2 → 1.25.0-f-poc-EC-3301.3

package/dist/_virtual/_commonjsHelpers.js

@@ -0,0 +1,6 @@
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+export {
+  getDefaultExportFromCjs
+};

package/dist/_virtual/_interop_require_default.js

@@ -0,0 +1,4 @@
+var _interop_require_default = {};
+export {
+  _interop_require_default as __exports
+};

package/dist/_virtual/_interop_require_wildcard.js

@@ -0,0 +1,4 @@
+var _interop_require_wildcard = {};
+export {
+  _interop_require_wildcard as __exports
+};

package/dist/_virtual/head-manager-context.shared-runtime.js

@@ -0,0 +1,4 @@
+var headManagerContext_sharedRuntime = {};
+export {
+  headManagerContext_sharedRuntime as __exports
+};

package/dist/_virtual/head-manager.js

@@ -0,0 +1,4 @@
+var headManager = { exports: {} };
+export {
+  headManager as __module
+};

package/dist/_virtual/request-idle-callback.js

@@ -0,0 +1,4 @@
+var requestIdleCallback = { exports: {} };
+export {
+  requestIdleCallback as __module
+};

package/dist/_virtual/script.js

@@ -0,0 +1,4 @@
+var script = { exports: {} };
+export {
+  script as __module
+};

package/dist/components/ImportMapScripts.js

@@ -1,7 +1,8 @@
 import { jsxs, Fragment, jsx } from "react/jsx-runtime";
 import "react";
 import "react-dom";
-import { generateImportMapJson } from "../services/generateImportMap.js";
+import { generateImportMapJson } from "../services/ImportMapService.js";
+import "../node_modules/next/dist/client/script.js";
 const ImportMapScripts = () => /* @__PURE__ */ jsxs(Fragment, { children: [
   /* @__PURE__ */ jsx(
     "script",

package/dist/hooks/useRemoteComponent.js

@@ -1,5 +1,7 @@
 import { useState, useCallback, useEffect } from "react";
 import { moduleLoader } from "../services/moduleLoader.js";
+import "react/jsx-runtime";
+import "../node_modules/next/dist/client/script.js";
 function useRemoteComponent(options) {
   const {
     manifest: manifestFromProps,

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="react" />
+
 import { default as default_2 } from 'react';
 
 export declare interface ComponentManifest {
@@ -8,13 +10,57 @@ export declare interface ComponentManifest {
 export declare function fetchManifest(manifestUrl: string): Promise<RemoteManifest>;
 
 /**
- * Generates an import map JSON string for ES module dependency resolution
- * This allows remote modules to use bare specifiers like 'react' instead of full CDN URLs
+ * Generate complete import map object for remote components
+ *
+ * @param config - Optional configuration to override default settings
+ * @returns Import map object ready for browser consumption
+ */
+export declare const generateImportMap: (config?: ImportMapConfig) => object;
+
+export declare const generateImportMapJson: (config?: ImportMapConfig) => string;
+
+/**
+ * Get import map script props for Next.js Script component
+ *
+ * @param config - Optional configuration to override default settings
+ * @returns Props object with type and dangerouslySetInnerHTML for Script component
+ * @example
+ * ```tsx
+ * <Script {...getImportMapScriptProps()} strategy="beforeInteractive" />
+ * ```
  */
-export declare function generateImportMapJson(): string;
+export declare const getImportMapScriptProps: (config?: ImportMapConfig) => {
+    type: "importmap-shim";
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+};
+
+export declare interface ImportMapConfig {
+    reactVersion?: string;
+    reactDomVersion?: string;
+    customImports?: Record<string, string>;
+}
+
+export declare const ImportMapScript: React.FC<ImportMapScriptProps>;
+
+declare interface ImportMapScriptProps {
+    reactVersion?: string;
+    reactDomVersion?: string;
+    customImports?: Record<string, string>;
+    strategy?: 'beforeInteractive' | 'afterInteractive' | 'lazyOnload';
+}
 
 export declare const ImportMapScripts: default_2.FC;
 
+/**
+ * Validate browser support for import maps
+ *
+ * @returns true if the browser supports import maps, false otherwise
+ * @see https://caniuse.com/import-maps
+ */
+export declare const isImportMapSupported: () => boolean;
+
 export declare class ModuleLoader {
     private loadedModules;
     private importMapInjected;

package/dist/index.js

@@ -1,17 +1,22 @@
 import { fetchManifest } from "./services/fetchManifest.js";
 import { ModuleLoader, moduleLoader } from "./services/moduleLoader.js";
-import { generateImportMapJson } from "./services/generateImportMap.js";
+import { generateImportMap, generateImportMapJson, getImportMapScriptProps, isImportMapSupported } from "./services/ImportMapService.js";
+import { ImportMapScript } from "./services/ImportMapScript.js";
 import { useRemoteComponent } from "./hooks/useRemoteComponent.js";
 import { RemoteRenderer } from "./components/RemoteRenderer.js";
 import { RemoteLinks } from "./components/RemoteLinks.js";
 import { ImportMapScripts } from "./components/ImportMapScripts.js";
 export {
+  ImportMapScript,
   ImportMapScripts,
   ModuleLoader,
   RemoteLinks,
   RemoteRenderer,
   fetchManifest,
+  generateImportMap,
   generateImportMapJson,
+  getImportMapScriptProps,
+  isImportMapSupported,
   moduleLoader,
   useRemoteComponent
 };

package/dist/node_modules/@swc/helpers/cjs/_interop_require_default.js

@@ -0,0 +1,8 @@
+import { __exports as _interop_require_default$1 } from "../../../../_virtual/_interop_require_default.js";
+_interop_require_default$1._ = _interop_require_default$1._interop_require_default = _interop_require_default;
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+export {
+  _interop_require_default$1 as default
+};

package/dist/node_modules/@swc/helpers/cjs/_interop_require_wildcard.js

@@ -0,0 +1,31 @@
+import { __exports as _interop_require_wildcard$1 } from "../../../../_virtual/_interop_require_wildcard.js";
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+_interop_require_wildcard$1._ = _interop_require_wildcard$1._interop_require_wildcard = _interop_require_wildcard;
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) return obj;
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) return cache.get(obj);
+  var newObj = { __proto__: null };
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+      else newObj[key] = obj[key];
+    }
+  }
+  newObj.default = obj;
+  if (cache) cache.set(obj, newObj);
+  return newObj;
+}
+export {
+  _interop_require_wildcard$1 as default
+};

package/dist/node_modules/next/dist/client/head-manager.js

@@ -0,0 +1,206 @@
+import { __module as headManager } from "../../../../_virtual/head-manager.js";
+var hasRequiredHeadManager;
+function requireHeadManager() {
+  if (hasRequiredHeadManager) return headManager.exports;
+  hasRequiredHeadManager = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      DOMAttributeNames: function() {
+        return DOMAttributeNames;
+      },
+      default: function() {
+        return initHeadManager;
+      },
+      isEqualNode: function() {
+        return isEqualNode;
+      }
+    });
+    const DOMAttributeNames = {
+      acceptCharset: "accept-charset",
+      className: "class",
+      htmlFor: "for",
+      httpEquiv: "http-equiv",
+      noModule: "noModule"
+    };
+    function reactElementToDOM(param) {
+      let { type, props } = param;
+      const el = document.createElement(type);
+      for (const p in props) {
+        if (!props.hasOwnProperty(p)) continue;
+        if (p === "children" || p === "dangerouslySetInnerHTML") continue;
+        if (props[p] === void 0) continue;
+        const attr = DOMAttributeNames[p] || p.toLowerCase();
+        if (type === "script" && (attr === "async" || attr === "defer" || attr === "noModule")) {
+          el[attr] = !!props[p];
+        } else {
+          el.setAttribute(attr, props[p]);
+        }
+      }
+      const { children, dangerouslySetInnerHTML } = props;
+      if (dangerouslySetInnerHTML) {
+        el.innerHTML = dangerouslySetInnerHTML.__html || "";
+      } else if (children) {
+        el.textContent = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : "";
+      }
+      return el;
+    }
+    function isEqualNode(oldTag, newTag) {
+      if (oldTag instanceof HTMLElement && newTag instanceof HTMLElement) {
+        const nonce = newTag.getAttribute("nonce");
+        if (nonce && !oldTag.getAttribute("nonce")) {
+          const cloneTag = newTag.cloneNode(true);
+          cloneTag.setAttribute("nonce", "");
+          cloneTag.nonce = nonce;
+          return nonce === oldTag.nonce && oldTag.isEqualNode(cloneTag);
+        }
+      }
+      return oldTag.isEqualNode(newTag);
+    }
+    let updateElements;
+    if (process.env.__NEXT_STRICT_NEXT_HEAD) {
+      updateElements = (type, components) => {
+        const headEl = document.querySelector("head");
+        if (!headEl) return;
+        const headMetaTags = headEl.querySelectorAll('meta[name="next-head"]') || [];
+        const oldTags = [];
+        if (type === "meta") {
+          const metaCharset = headEl.querySelector("meta[charset]");
+          if (metaCharset) {
+            oldTags.push(metaCharset);
+          }
+        }
+        for (let i = 0; i < headMetaTags.length; i++) {
+          var _headTag_tagName;
+          const metaTag = headMetaTags[i];
+          const headTag = metaTag.nextSibling;
+          if ((headTag == null ? void 0 : (_headTag_tagName = headTag.tagName) == null ? void 0 : _headTag_tagName.toLowerCase()) === type) {
+            oldTags.push(headTag);
+          }
+        }
+        const newTags = components.map(reactElementToDOM).filter((newTag) => {
+          for (let k = 0, len = oldTags.length; k < len; k++) {
+            const oldTag = oldTags[k];
+            if (isEqualNode(oldTag, newTag)) {
+              oldTags.splice(k, 1);
+              return false;
+            }
+          }
+          return true;
+        });
+        oldTags.forEach((t) => {
+          var _t_parentNode;
+          const metaTag = t.previousSibling;
+          if (metaTag && metaTag.getAttribute("name") === "next-head") {
+            var _t_parentNode1;
+            (_t_parentNode1 = t.parentNode) == null ? void 0 : _t_parentNode1.removeChild(metaTag);
+          }
+          (_t_parentNode = t.parentNode) == null ? void 0 : _t_parentNode.removeChild(t);
+        });
+        newTags.forEach((t) => {
+          var _t_tagName;
+          const meta = document.createElement("meta");
+          meta.name = "next-head";
+          meta.content = "1";
+          if (!(((_t_tagName = t.tagName) == null ? void 0 : _t_tagName.toLowerCase()) === "meta" && t.getAttribute("charset"))) {
+            headEl.appendChild(meta);
+          }
+          headEl.appendChild(t);
+        });
+      };
+    } else {
+      updateElements = (type, components) => {
+        const headEl = document.getElementsByTagName("head")[0];
+        const headCountEl = headEl.querySelector("meta[name=next-head-count]");
+        if (process.env.NODE_ENV !== "production") {
+          if (!headCountEl) {
+            console.error("Warning: next-head-count is missing. https://nextjs.org/docs/messages/next-head-count-missing");
+            return;
+          }
+        }
+        const headCount = Number(headCountEl.content);
+        const oldTags = [];
+        for (let i = 0, j = headCountEl.previousElementSibling; i < headCount; i++, j = (j == null ? void 0 : j.previousElementSibling) || null) {
+          var _j_tagName;
+          if ((j == null ? void 0 : (_j_tagName = j.tagName) == null ? void 0 : _j_tagName.toLowerCase()) === type) {
+            oldTags.push(j);
+          }
+        }
+        const newTags = components.map(reactElementToDOM).filter((newTag) => {
+          for (let k = 0, len = oldTags.length; k < len; k++) {
+            const oldTag = oldTags[k];
+            if (isEqualNode(oldTag, newTag)) {
+              oldTags.splice(k, 1);
+              return false;
+            }
+          }
+          return true;
+        });
+        oldTags.forEach((t) => {
+          var _t_parentNode;
+          return (_t_parentNode = t.parentNode) == null ? void 0 : _t_parentNode.removeChild(t);
+        });
+        newTags.forEach((t) => headEl.insertBefore(t, headCountEl));
+        headCountEl.content = (headCount - oldTags.length + newTags.length).toString();
+      };
+    }
+    function initHeadManager() {
+      return {
+        mountedInstances: /* @__PURE__ */ new Set(),
+        updateHead: (head) => {
+          const tags = {};
+          head.forEach((h) => {
+            if (
+              // If the font tag is loaded only on client navigation
+              // it won't be inlined. In this case revert to the original behavior
+              h.type === "link" && h.props["data-optimized-fonts"]
+            ) {
+              if (document.querySelector('style[data-href="' + h.props["data-href"] + '"]')) {
+                return;
+              } else {
+                h.props.href = h.props["data-href"];
+                h.props["data-href"] = void 0;
+              }
+            }
+            const components = tags[h.type] || [];
+            components.push(h);
+            tags[h.type] = components;
+          });
+          const titleComponent = tags.title ? tags.title[0] : null;
+          let title = "";
+          if (titleComponent) {
+            const { children } = titleComponent.props;
+            title = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : "";
+          }
+          if (title !== document.title) document.title = title;
+          [
+            "meta",
+            "base",
+            "link",
+            "style",
+            "script"
+          ].forEach((type) => {
+            updateElements(type, tags[type] || []);
+          });
+        }
+      };
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(headManager, headManager.exports);
+  return headManager.exports;
+}
+export {
+  requireHeadManager as __require
+};

package/dist/node_modules/next/dist/client/request-idle-callback.js

@@ -0,0 +1,48 @@
+import { __module as requestIdleCallback } from "../../../../_virtual/request-idle-callback.js";
+var hasRequiredRequestIdleCallback;
+function requireRequestIdleCallback() {
+  if (hasRequiredRequestIdleCallback) return requestIdleCallback.exports;
+  hasRequiredRequestIdleCallback = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      cancelIdleCallback: function() {
+        return cancelIdleCallback;
+      },
+      requestIdleCallback: function() {
+        return requestIdleCallback2;
+      }
+    });
+    const requestIdleCallback2 = typeof self !== "undefined" && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+      let start = Date.now();
+      return self.setTimeout(function() {
+        cb({
+          didTimeout: false,
+          timeRemaining: function() {
+            return Math.max(0, 50 - (Date.now() - start));
+          }
+        });
+      }, 1);
+    };
+    const cancelIdleCallback = typeof self !== "undefined" && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function(id) {
+      return clearTimeout(id);
+    };
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(requestIdleCallback, requestIdleCallback.exports);
+  return requestIdleCallback.exports;
+}
+export {
+  requireRequestIdleCallback as __require
+};

package/dist/node_modules/next/dist/client/script.js

@@ -0,0 +1,298 @@
+import { __module as script } from "../../../../_virtual/script.js";
+import "../../../@swc/helpers/cjs/_interop_require_default.js";
+import "../../../@swc/helpers/cjs/_interop_require_wildcard.js";
+import require$$2 from "react/jsx-runtime";
+import ReactDOM from "react-dom";
+import React from "react";
+import { __require as requireHeadManagerContext_sharedRuntime } from "../shared/lib/head-manager-context.shared-runtime.js";
+import { __require as requireHeadManager } from "./head-manager.js";
+import { __require as requireRequestIdleCallback } from "./request-idle-callback.js";
+import { __exports as _interop_require_wildcard } from "../../../../_virtual/_interop_require_wildcard.js";
+import { __exports as _interop_require_default } from "../../../../_virtual/_interop_require_default.js";
+(function(module, exports$1) {
+  "use client";
+  Object.defineProperty(exports$1, "__esModule", {
+    value: true
+  });
+  function _export(target, all) {
+    for (var name in all) Object.defineProperty(target, name, {
+      enumerable: true,
+      get: all[name]
+    });
+  }
+  _export(exports$1, {
+    default: function() {
+      return _default;
+    },
+    handleClientScriptLoad: function() {
+      return handleClientScriptLoad;
+    },
+    initScriptLoader: function() {
+      return initScriptLoader;
+    }
+  });
+  const _interop_require_default$1 = _interop_require_default;
+  const _interop_require_wildcard$1 = _interop_require_wildcard;
+  const _jsxruntime = require$$2;
+  const _reactdom = /* @__PURE__ */ _interop_require_default$1._(ReactDOM);
+  const _react = /* @__PURE__ */ _interop_require_wildcard$1._(React);
+  const _headmanagercontextsharedruntime = requireHeadManagerContext_sharedRuntime();
+  const _headmanager = requireHeadManager();
+  const _requestidlecallback = requireRequestIdleCallback();
+  const ScriptCache = /* @__PURE__ */ new Map();
+  const LoadCache = /* @__PURE__ */ new Set();
+  const ignoreProps = [
+    "onLoad",
+    "onReady",
+    "dangerouslySetInnerHTML",
+    "children",
+    "onError",
+    "strategy",
+    "stylesheets"
+  ];
+  const insertStylesheets = (stylesheets) => {
+    if (_reactdom.default.preinit) {
+      stylesheets.forEach((stylesheet) => {
+        _reactdom.default.preinit(stylesheet, {
+          as: "style"
+        });
+      });
+      return;
+    }
+    if (typeof window !== "undefined") {
+      let head = document.head;
+      stylesheets.forEach((stylesheet) => {
+        let link = document.createElement("link");
+        link.type = "text/css";
+        link.rel = "stylesheet";
+        link.href = stylesheet;
+        head.appendChild(link);
+      });
+    }
+  };
+  const loadScript = (props) => {
+    const { src, id, onLoad = () => {
+    }, onReady = null, dangerouslySetInnerHTML, children = "", strategy = "afterInteractive", onError, stylesheets } = props;
+    const cacheKey = id || src;
+    if (cacheKey && LoadCache.has(cacheKey)) {
+      return;
+    }
+    if (ScriptCache.has(src)) {
+      LoadCache.add(cacheKey);
+      ScriptCache.get(src).then(onLoad, onError);
+      return;
+    }
+    const afterLoad = () => {
+      if (onReady) {
+        onReady();
+      }
+      LoadCache.add(cacheKey);
+    };
+    const el = document.createElement("script");
+    const loadPromise = new Promise((resolve, reject) => {
+      el.addEventListener("load", function(e) {
+        resolve();
+        if (onLoad) {
+          onLoad.call(this, e);
+        }
+        afterLoad();
+      });
+      el.addEventListener("error", function(e) {
+        reject(e);
+      });
+    }).catch(function(e) {
+      if (onError) {
+        onError(e);
+      }
+    });
+    if (dangerouslySetInnerHTML) {
+      el.innerHTML = dangerouslySetInnerHTML.__html || "";
+      afterLoad();
+    } else if (children) {
+      el.textContent = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : "";
+      afterLoad();
+    } else if (src) {
+      el.src = src;
+      ScriptCache.set(src, loadPromise);
+    }
+    for (const [k, value] of Object.entries(props)) {
+      if (value === void 0 || ignoreProps.includes(k)) {
+        continue;
+      }
+      const attr = _headmanager.DOMAttributeNames[k] || k.toLowerCase();
+      el.setAttribute(attr, value);
+    }
+    if (strategy === "worker") {
+      el.setAttribute("type", "text/partytown");
+    }
+    el.setAttribute("data-nscript", strategy);
+    if (stylesheets) {
+      insertStylesheets(stylesheets);
+    }
+    document.body.appendChild(el);
+  };
+  function handleClientScriptLoad(props) {
+    const { strategy = "afterInteractive" } = props;
+    if (strategy === "lazyOnload") {
+      window.addEventListener("load", () => {
+        (0, _requestidlecallback.requestIdleCallback)(() => loadScript(props));
+      });
+    } else {
+      loadScript(props);
+    }
+  }
+  function loadLazyScript(props) {
+    if (document.readyState === "complete") {
+      (0, _requestidlecallback.requestIdleCallback)(() => loadScript(props));
+    } else {
+      window.addEventListener("load", () => {
+        (0, _requestidlecallback.requestIdleCallback)(() => loadScript(props));
+      });
+    }
+  }
+  function addBeforeInteractiveToCache() {
+    const scripts = [
+      ...document.querySelectorAll('[data-nscript="beforeInteractive"]'),
+      ...document.querySelectorAll('[data-nscript="beforePageRender"]')
+    ];
+    scripts.forEach((script2) => {
+      const cacheKey = script2.id || script2.getAttribute("src");
+      LoadCache.add(cacheKey);
+    });
+  }
+  function initScriptLoader(scriptLoaderItems) {
+    scriptLoaderItems.forEach(handleClientScriptLoad);
+    addBeforeInteractiveToCache();
+  }
+  function Script(props) {
+    const { id, src = "", onLoad = () => {
+    }, onReady = null, strategy = "afterInteractive", onError, stylesheets, ...restProps } = props;
+    const { updateScripts, scripts, getIsSsr, appDir, nonce } = (0, _react.useContext)(_headmanagercontextsharedruntime.HeadManagerContext);
+    const hasOnReadyEffectCalled = (0, _react.useRef)(false);
+    (0, _react.useEffect)(() => {
+      const cacheKey = id || src;
+      if (!hasOnReadyEffectCalled.current) {
+        if (onReady && cacheKey && LoadCache.has(cacheKey)) {
+          onReady();
+        }
+        hasOnReadyEffectCalled.current = true;
+      }
+    }, [
+      onReady,
+      id,
+      src
+    ]);
+    const hasLoadScriptEffectCalled = (0, _react.useRef)(false);
+    (0, _react.useEffect)(() => {
+      if (!hasLoadScriptEffectCalled.current) {
+        if (strategy === "afterInteractive") {
+          loadScript(props);
+        } else if (strategy === "lazyOnload") {
+          loadLazyScript(props);
+        }
+        hasLoadScriptEffectCalled.current = true;
+      }
+    }, [
+      props,
+      strategy
+    ]);
+    if (strategy === "beforeInteractive" || strategy === "worker") {
+      if (updateScripts) {
+        scripts[strategy] = (scripts[strategy] || []).concat([
+          {
+            id,
+            src,
+            onLoad,
+            onReady,
+            onError,
+            ...restProps
+          }
+        ]);
+        updateScripts(scripts);
+      } else if (getIsSsr && getIsSsr()) {
+        LoadCache.add(id || src);
+      } else if (getIsSsr && !getIsSsr()) {
+        loadScript(props);
+      }
+    }
+    if (appDir) {
+      if (stylesheets) {
+        stylesheets.forEach((styleSrc) => {
+          _reactdom.default.preinit(styleSrc, {
+            as: "style"
+          });
+        });
+      }
+      if (strategy === "beforeInteractive") {
+        if (!src) {
+          if (restProps.dangerouslySetInnerHTML) {
+            restProps.children = restProps.dangerouslySetInnerHTML.__html;
+            delete restProps.dangerouslySetInnerHTML;
+          }
+          return /* @__PURE__ */ (0, _jsxruntime.jsx)("script", {
+            nonce,
+            dangerouslySetInnerHTML: {
+              __html: "(self.__next_s=self.__next_s||[]).push(" + JSON.stringify([
+                0,
+                {
+                  ...restProps,
+                  id
+                }
+              ]) + ")"
+            }
+          });
+        } else {
+          _reactdom.default.preload(src, restProps.integrity ? {
+            as: "script",
+            integrity: restProps.integrity,
+            nonce,
+            crossOrigin: restProps.crossOrigin
+          } : {
+            as: "script",
+            nonce,
+            crossOrigin: restProps.crossOrigin
+          });
+          return /* @__PURE__ */ (0, _jsxruntime.jsx)("script", {
+            nonce,
+            dangerouslySetInnerHTML: {
+              __html: "(self.__next_s=self.__next_s||[]).push(" + JSON.stringify([
+                src,
+                {
+                  ...restProps,
+                  id
+                }
+              ]) + ")"
+            }
+          });
+        }
+      } else if (strategy === "afterInteractive") {
+        if (src) {
+          _reactdom.default.preload(src, restProps.integrity ? {
+            as: "script",
+            integrity: restProps.integrity,
+            nonce,
+            crossOrigin: restProps.crossOrigin
+          } : {
+            as: "script",
+            nonce,
+            crossOrigin: restProps.crossOrigin
+          });
+        }
+      }
+    }
+    return null;
+  }
+  Object.defineProperty(Script, "__nextScript", {
+    value: true
+  });
+  const _default = Script;
+  if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+    Object.defineProperty(exports$1.default, "__esModule", { value: true });
+    Object.assign(exports$1.default, exports$1);
+    module.exports = exports$1.default;
+  }
+})(script, script.exports);
+var scriptExports = script.exports;
+export {
+  scriptExports as s
+};

package/dist/node_modules/next/dist/shared/lib/head-manager-context.shared-runtime.js

@@ -0,0 +1,30 @@
+import { __exports as headManagerContext_sharedRuntime } from "../../../../../_virtual/head-manager-context.shared-runtime.js";
+import "../../../../@swc/helpers/cjs/_interop_require_default.js";
+import React from "react";
+import { __exports as _interop_require_default } from "../../../../../_virtual/_interop_require_default.js";
+var hasRequiredHeadManagerContext_sharedRuntime;
+function requireHeadManagerContext_sharedRuntime() {
+  if (hasRequiredHeadManagerContext_sharedRuntime) return headManagerContext_sharedRuntime;
+  hasRequiredHeadManagerContext_sharedRuntime = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "HeadManagerContext", {
+      enumerable: true,
+      get: function() {
+        return HeadManagerContext;
+      }
+    });
+    const _interop_require_default$1 = _interop_require_default;
+    const _react = /* @__PURE__ */ _interop_require_default$1._(React);
+    const HeadManagerContext = _react.default.createContext({});
+    if (process.env.NODE_ENV !== "production") {
+      HeadManagerContext.displayName = "HeadManagerContext";
+    }
+  })(headManagerContext_sharedRuntime);
+  return headManagerContext_sharedRuntime;
+}
+export {
+  requireHeadManagerContext_sharedRuntime as __require
+};

package/dist/node_modules/next/script.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from "../../_virtual/_commonjsHelpers.js";
+import { s as scriptExports } from "./dist/client/script.js";
+var script = scriptExports;
+const Script = /* @__PURE__ */ getDefaultExportFromCjs(script);
+export {
+  Script as default
+};

package/dist/packages/shared-utils/package.json.js

@@ -0,0 +1,11 @@
+const dependencies = {
+  react: "^18.3.1",
+  "react-dom": "^18.3.1"
+};
+const packageJson = {
+  dependencies
+};
+export {
+  packageJson as default,
+  dependencies
+};

package/dist/services/ImportMapScript.js

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import Script from "../node_modules/next/script.js";
+import { getImportMapScriptProps } from "./ImportMapService.js";
+const ImportMapScript = ({
+  reactVersion,
+  reactDomVersion,
+  customImports,
+  strategy = "beforeInteractive"
+}) => {
+  const scriptProps = getImportMapScriptProps({
+    reactVersion,
+    reactDomVersion,
+    customImports
+  });
+  return /* @__PURE__ */ jsx(
+    Script,
+    {
+      id: "remote-components-import-map",
+      strategy,
+      ...scriptProps
+    }
+  );
+};
+export {
+  ImportMapScript
+};

package/dist/services/ImportMapService.js

@@ -0,0 +1,61 @@
+import packageJson from "../packages/shared-utils/package.json.js";
+const cleanVersion = (version) => {
+  return version.replace(/^[\^~]/, "");
+};
+const DEFAULT_CONFIG = {
+  reactVersion: cleanVersion(packageJson.dependencies.react),
+  reactDomVersion: cleanVersion(packageJson.dependencies["react-dom"])
+};
+const generateReactDataUrl = () => {
+  return `data:text/javascript;charset=utf-8,
+const React = window.React;
+export default React;
+export const {
+  Component, PureComponent, createContext, useContext, useState, useEffect,
+  useCallback, useMemo, useRef, forwardRef, createElement, Fragment, memo, lazy, Suspense,
+  useLayoutEffect, useId
+} = React;`;
+};
+const generateJsxRuntimeDataUrl = () => {
+  return `data:text/javascript;charset=utf-8,
+import * as ReactJSXRuntime from 'https://esm.sh/react@18.3.1/jsx-runtime';
+export const jsx = ReactJSXRuntime.jsx;
+export const jsxs = ReactJSXRuntime.jsxs;
+export const Fragment = ReactJSXRuntime.Fragment;`;
+};
+const generateImportMap = (config = {}) => {
+  const finalConfig = { ...DEFAULT_CONFIG, ...config };
+  return {
+    imports: {
+      react: generateReactDataUrl(),
+      "react/jsx-runtime": generateJsxRuntimeDataUrl(),
+      "react/jsx-dev-runtime": generateJsxRuntimeDataUrl(),
+      // Some bundlers emit ".js" suffixed bare specifiers; map those too
+      "react/jsx-runtime.js": generateJsxRuntimeDataUrl(),
+      "react/jsx-dev-runtime.js": generateJsxRuntimeDataUrl(),
+      "react-dom": `https://esm.sh/react-dom@${finalConfig.reactDomVersion}`,
+      "react-dom/client": `https://esm.sh/react-dom@${finalConfig.reactDomVersion}/client`
+    }
+  };
+};
+const generateImportMapJson = (config) => {
+  return JSON.stringify(generateImportMap(config));
+};
+const isImportMapSupported = () => {
+  if (typeof window === "undefined") return false;
+  return "importmap" in document.createElement("script");
+};
+const getImportMapScriptProps = (config) => {
+  return {
+    type: "importmap-shim",
+    dangerouslySetInnerHTML: {
+      __html: generateImportMapJson(config)
+    }
+  };
+};
+export {
+  generateImportMap,
+  generateImportMapJson,
+  getImportMapScriptProps,
+  isImportMapSupported
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaena1/mm-ui-shared-utils",
-  "version": "1.25.0-f-poc-EC-3301.2",
+  "version": "1.25.0-f-poc-EC-3301.3",
   "description": "Shared utilities for loading remote React components in Mint Mobile microfrontends",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,6 +35,10 @@
   ],
   "author": "",
   "license": "ISC",
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
   "peerDependencies": {
     "react": "^18.3.1",
     "react-dom": "^18.3.1"

package/dist/services/generateImportMap.js

@@ -1,14 +0,0 @@
-function generateImportMapJson() {
-  const importMap = {
-    imports: {
-      react: "react",
-      "react-dom": "react-dom",
-      "react/jsx-runtime": "react/jsx-runtime",
-      "react/jsx-dev-runtime": "react/jsx-dev-runtime"
-    }
-  };
-  return JSON.stringify(importMap);
-}
-export {
-  generateImportMapJson
-};