@gears-frontx/react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,903 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ACCOUNTS_DOMAIN: () => import_framework6.ACCOUNTS_DOMAIN,
+  ApiPlugin: () => import_framework6.ApiPlugin,
+  ApiPluginBase: () => import_framework6.ApiPluginBase,
+  ApiProtocol: () => import_framework6.ApiProtocol,
+  BaseApiService: () => import_framework6.BaseApiService,
+  ContainerProvider: () => import_framework15.ContainerProvider,
+  ExtensionDomainSlot: () => ExtensionDomainSlot,
+  FRONTX_ACTION_LOAD_EXT: () => import_framework13.FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT: () => import_framework13.FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT: () => import_framework13.FRONTX_ACTION_UNMOUNT_EXT,
+  FRONTX_MFE_ENTRY_MF: () => import_framework12.FRONTX_MFE_ENTRY_MF,
+  FRONTX_OVERLAY_DOMAIN: () => import_framework11.FRONTX_OVERLAY_DOMAIN,
+  FRONTX_POPUP_DOMAIN: () => import_framework11.FRONTX_POPUP_DOMAIN,
+  FRONTX_SCREEN_DOMAIN: () => import_framework11.FRONTX_SCREEN_DOMAIN,
+  FRONTX_SCREEN_EXTENSION_TYPE: () => import_framework12.FRONTX_SCREEN_EXTENSION_TYPE,
+  FRONTX_SHARED_PROPERTY_LANGUAGE: () => import_framework14.FRONTX_SHARED_PROPERTY_LANGUAGE,
+  FRONTX_SHARED_PROPERTY_THEME: () => import_framework14.FRONTX_SHARED_PROPERTY_THEME,
+  FRONTX_SIDEBAR_DOMAIN: () => import_framework11.FRONTX_SIDEBAR_DOMAIN,
+  HAI3Context: () => HAI3Context,
+  HAI3Provider: () => HAI3Provider,
+  I18nRegistry: () => import_framework6.I18nRegistry,
+  I18nRegistryImpl: () => import_framework6.I18nRegistryImpl,
+  LAYOUT_SLICE_NAME: () => import_framework6.LAYOUT_SLICE_NAME,
+  Language: () => import_framework7.Language,
+  LanguageDisplayMode: () => import_framework7.LanguageDisplayMode,
+  LayoutDomain: () => import_framework6.LayoutDomain,
+  MOCK_PLUGIN: () => import_framework6.MOCK_PLUGIN,
+  MfeBridgeFactory: () => import_framework15.MfeBridgeFactory,
+  MfeContext: () => MfeContext,
+  MfeHandler: () => import_framework15.MfeHandler,
+  MfeHandlerMF: () => import_framework16.MfeHandlerMF,
+  MfeProvider: () => MfeProvider,
+  MockEventSource: () => import_framework6.MockEventSource,
+  MockEvents: () => import_framework6.MockEvents,
+  RefContainerProvider: () => RefContainerProvider,
+  RestMockPlugin: () => import_framework6.RestMockPlugin,
+  RestPlugin: () => import_framework6.RestPlugin,
+  RestPluginWithConfig: () => import_framework6.RestPluginWithConfig,
+  RestProtocol: () => import_framework6.RestProtocol,
+  SUPPORTED_LANGUAGES: () => import_framework6.SUPPORTED_LANGUAGES,
+  ScreensetsRegistry: () => import_framework15.ScreensetsRegistry,
+  ScreensetsRegistryFactory: () => import_framework15.ScreensetsRegistryFactory,
+  SseMockPlugin: () => import_framework6.SseMockPlugin,
+  SsePlugin: () => import_framework6.SsePlugin,
+  SsePluginWithConfig: () => import_framework6.SsePluginWithConfig,
+  SseProtocol: () => import_framework6.SseProtocol,
+  TENANT_SLICE_NAME: () => import_framework6.TENANT_SLICE_NAME,
+  TenantEvents: () => import_framework6.TenantEvents,
+  TextDirection: () => import_framework7.TextDirection,
+  apiRegistry: () => import_framework6.apiRegistry,
+  changeTenant: () => import_framework6.changeTenant,
+  clearActiveScreen: () => import_framework6.clearActiveScreen,
+  clearTenant: () => import_framework6.clearTenant,
+  clearTenantAction: () => import_framework6.clearTenantAction,
+  clearUser: () => import_framework6.clearUser,
+  closeAllPopups: () => import_framework6.closeAllPopups,
+  closePopup: () => import_framework6.closePopup,
+  closeTopPopup: () => import_framework6.closeTopPopup,
+  createHAI3: () => import_framework6.createHAI3,
+  createHAI3App: () => import_framework6.createHAI3App,
+  createI18nRegistry: () => import_framework6.createI18nRegistry,
+  createShadowRoot: () => import_framework18.createShadowRoot,
+  createSlice: () => import_framework6.createSlice,
+  createStore: () => import_framework6.createStore,
+  createThemeRegistry: () => import_framework6.createThemeRegistry,
+  effects: () => import_framework6.effects,
+  eventBus: () => eventBus,
+  extensionScreenSchema: () => import_framework17.extensionScreenSchema,
+  extractGtsPackage: () => import_framework18.extractGtsPackage,
+  footerActions: () => import_framework6.footerActions,
+  footerSlice: () => import_framework6.footerSlice,
+  getLanguageMetadata: () => import_framework6.getLanguageMetadata,
+  getStore: () => import_framework6.getStore,
+  gtsPlugin: () => import_framework16.gtsPlugin,
+  hasSlice: () => import_framework6.hasSlice,
+  headerActions: () => import_framework6.headerActions,
+  headerSlice: () => import_framework6.headerSlice,
+  hideOverlay: () => import_framework6.hideOverlay,
+  i18n: () => import_framework6.i18n,
+  i18nRegistry: () => import_framework6.i18nRegistry,
+  initMockEffects: () => import_framework6.initMockEffects,
+  initTenantEffects: () => import_framework6.initTenantEffects,
+  injectCssVariables: () => import_framework18.injectCssVariables,
+  isMockPlugin: () => import_framework6.isMockPlugin,
+  isRestShortCircuit: () => import_framework6.isRestShortCircuit,
+  isShortCircuit: () => import_framework6.isShortCircuit,
+  isSseShortCircuit: () => import_framework6.isSseShortCircuit,
+  languageSchema: () => import_framework17.languageSchema,
+  layout: () => import_framework6.layout,
+  layoutDomainReducers: () => import_framework6.layoutDomainReducers,
+  layoutReducer: () => import_framework6.layoutReducer,
+  loadExtension: () => import_framework9.loadExtension,
+  menuActions: () => import_framework6.menuActions,
+  menuSlice: () => import_framework6.menuSlice,
+  microfrontends: () => import_framework8.microfrontends,
+  mock: () => import_framework8.mock,
+  mockActions: () => import_framework6.mockActions,
+  mockSlice: () => import_framework6.mockSlice,
+  mountExtension: () => import_framework9.mountExtension,
+  navigateTo: () => import_framework6.navigateTo,
+  openPopup: () => import_framework6.openPopup,
+  overlayActions: () => import_framework6.overlayActions,
+  overlayDomain: () => import_framework11.overlayDomain,
+  overlaySlice: () => import_framework6.overlaySlice,
+  popupActions: () => import_framework6.popupActions,
+  popupDomain: () => import_framework11.popupDomain,
+  popupSlice: () => import_framework6.popupSlice,
+  presets: () => import_framework6.presets,
+  registerExtension: () => import_framework9.registerExtension,
+  registerSlice: () => import_framework6.registerSlice,
+  screenActions: () => import_framework6.screenActions,
+  screenDomain: () => import_framework11.screenDomain,
+  screenSlice: () => import_framework6.screenSlice,
+  screensets: () => import_framework6.screensets,
+  screensetsRegistryFactory: () => import_framework15.screensetsRegistryFactory,
+  selectExtensionError: () => import_framework10.selectExtensionError,
+  selectExtensionState: () => import_framework10.selectExtensionState,
+  selectRegisteredExtensions: () => import_framework10.selectRegisteredExtensions,
+  setActiveScreen: () => import_framework6.setActiveScreen,
+  setFooterConfig: () => import_framework6.setFooterConfig,
+  setFooterVisible: () => import_framework6.setFooterVisible,
+  setHeaderLoading: () => import_framework6.setHeaderLoading,
+  setMenuCollapsed: () => import_framework6.setMenuCollapsed,
+  setMenuConfig: () => import_framework6.setMenuConfig,
+  setMenuItems: () => import_framework6.setMenuItems,
+  setMenuVisible: () => import_framework6.setMenuVisible,
+  setMockEnabled: () => import_framework6.setMockEnabled,
+  setOverlayVisible: () => import_framework6.setOverlayVisible,
+  setScreenLoading: () => import_framework6.setScreenLoading,
+  setSidebarCollapsed: () => import_framework6.setSidebarCollapsed,
+  setSidebarConfig: () => import_framework6.setSidebarConfig,
+  setSidebarContent: () => import_framework6.setSidebarContent,
+  setSidebarPosition: () => import_framework6.setSidebarPosition,
+  setSidebarTitle: () => import_framework6.setSidebarTitle,
+  setSidebarVisible: () => import_framework6.setSidebarVisible,
+  setSidebarWidth: () => import_framework6.setSidebarWidth,
+  setTenant: () => import_framework6.setTenant,
+  setTenantLoading: () => import_framework6.setTenantLoading,
+  setTenantLoadingState: () => import_framework6.setTenantLoadingState,
+  setUser: () => import_framework6.setUser,
+  showOverlay: () => import_framework6.showOverlay,
+  sidebarActions: () => import_framework6.sidebarActions,
+  sidebarDomain: () => import_framework11.sidebarDomain,
+  sidebarSlice: () => import_framework6.sidebarSlice,
+  tenantActions: () => import_framework6.tenantActions,
+  tenantReducer: () => import_framework6.tenantReducer,
+  tenantSlice: () => import_framework6.tenantSlice,
+  themeSchema: () => import_framework17.themeSchema,
+  themes: () => import_framework6.themes,
+  toggleMenu: () => import_framework6.toggleMenu,
+  toggleMockMode: () => import_framework6.toggleMockMode,
+  toggleSidebar: () => import_framework6.toggleSidebar,
+  unmountExtension: () => import_framework9.unmountExtension,
+  unregisterExtension: () => import_framework9.unregisterExtension,
+  useActivePackage: () => useActivePackage,
+  useAppDispatch: () => useAppDispatch,
+  useAppSelector: () => useAppSelector,
+  useDomainExtensions: () => useDomainExtensions,
+  useFormatters: () => useFormatters,
+  useHAI3: () => useHAI3,
+  useHostAction: () => useHostAction,
+  useMfeBridge: () => useMfeBridge,
+  useMfeContext: () => useMfeContext,
+  useRegisteredPackages: () => useRegisteredPackages,
+  useScreenTranslations: () => useScreenTranslations,
+  useSharedProperty: () => useSharedProperty,
+  useTheme: () => useTheme,
+  useTranslation: () => useTranslation
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/HAI3Provider.tsx
+var import_react3 = require("react");
+var import_react_redux = require("react-redux");
+var import_framework = require("@gears-frontx/framework");
+
+// src/HAI3Context.tsx
+var import_react = require("react");
+var HAI3Context = (0, import_react.createContext)(null);
+function useHAI3() {
+  const context = (0, import_react.useContext)(HAI3Context);
+  if (!context) {
+    throw new Error(
+      "useHAI3 must be used within a HAI3Provider. Wrap your application with <HAI3Provider> to access HAI3 features."
+    );
+  }
+  return context;
+}
+
+// src/mfe/MfeContext.tsx
+var import_react2 = require("react");
+var MfeContext = (0, import_react2.createContext)(null);
+function useMfeContext() {
+  const context = (0, import_react2.useContext)(MfeContext);
+  if (!context) {
+    throw new Error(
+      "useMfeContext must be used within a MfeProvider. This hook can only be used inside MFE components."
+    );
+  }
+  return context;
+}
+
+// src/mfe/MfeProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MfeProvider = ({ value, children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MfeContext.Provider, { value, children });
+};
+
+// src/HAI3Provider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var HAI3Provider = ({
+  children,
+  config,
+  app: providedApp,
+  mfeBridge
+}) => {
+  const app = (0, import_react3.useMemo)(() => {
+    if (providedApp) {
+      return providedApp;
+    }
+    return (0, import_framework.createHAI3App)(config);
+  }, [providedApp, config]);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (!providedApp) {
+        app.destroy();
+      }
+    };
+  }, [app, providedApp]);
+  const content = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(HAI3Context.Provider, { value: app, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_redux.Provider, { store: app.store, children }) });
+  if (mfeBridge) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MfeProvider, { value: mfeBridge, children: content });
+  }
+  return content;
+};
+
+// src/hooks/useAppDispatch.ts
+var import_react_redux2 = require("react-redux");
+function useAppDispatch() {
+  return (0, import_react_redux2.useDispatch)();
+}
+
+// src/hooks/useAppSelector.ts
+var import_react_redux3 = require("react-redux");
+var useAppSelector = import_react_redux3.useSelector;
+
+// src/hooks/useTranslation.ts
+var import_react4 = require("react");
+function useTranslation() {
+  const app = useHAI3();
+  const { i18nRegistry: i18nRegistry2 } = app;
+  const version = (0, import_react4.useSyncExternalStore)(
+    (0, import_react4.useCallback)(
+      (callback) => {
+        return i18nRegistry2.subscribe(callback);
+      },
+      [i18nRegistry2]
+    ),
+    () => i18nRegistry2.getVersion(),
+    () => i18nRegistry2.getVersion()
+  );
+  const language = (0, import_react4.useMemo)(() => {
+    void version;
+    return i18nRegistry2.getLanguage();
+  }, [i18nRegistry2, version]);
+  const t = (0, import_react4.useCallback)(
+    (key, params) => {
+      return i18nRegistry2.t(key, params);
+    },
+    [i18nRegistry2]
+  );
+  const setLanguage = (0, import_react4.useCallback)(
+    (lang) => {
+      if (app.actions.setLanguage) {
+        app.actions.setLanguage({ language: lang });
+      }
+    },
+    [app.actions]
+  );
+  const isRTL = (0, import_react4.useMemo)(() => {
+    void language;
+    return i18nRegistry2.isRTL();
+  }, [i18nRegistry2, language]);
+  return {
+    t,
+    language,
+    setLanguage,
+    isRTL
+  };
+}
+
+// src/hooks/useScreenTranslations.ts
+var import_react5 = require("react");
+function isTranslationLoader(input) {
+  return typeof input === "function";
+}
+function useScreenTranslations(screensetId, screenId, translations) {
+  const app = useHAI3();
+  const { i18nRegistry: i18nRegistry2 } = app;
+  const [loadedLanguage, setLoadedLanguage] = (0, import_react5.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const version = (0, import_react5.useSyncExternalStore)(
+    (0, import_react5.useCallback)(
+      (callback) => i18nRegistry2.subscribe(callback),
+      [i18nRegistry2]
+    ),
+    () => i18nRegistry2.getVersion(),
+    () => i18nRegistry2.getVersion()
+  );
+  const currentLanguage = (0, import_react5.useMemo)(() => {
+    void version;
+    return i18nRegistry2.getLanguage();
+  }, [i18nRegistry2, version]);
+  const loader = (0, import_react5.useMemo)(() => {
+    if (isTranslationLoader(translations)) {
+      return translations;
+    }
+    return async (language) => {
+      const importFn = translations[language];
+      if (!importFn) {
+        return {};
+      }
+      const module2 = await importFn();
+      return module2.default;
+    };
+  }, [translations]);
+  (0, import_react5.useEffect)(() => {
+    if (!currentLanguage || currentLanguage === loadedLanguage) {
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    const loadTranslations = async () => {
+      try {
+        const namespace = `screen.${screensetId}.${screenId}`;
+        i18nRegistry2.registerLoader(namespace, loader);
+        const loadedTranslations = await loader(currentLanguage);
+        i18nRegistry2.register(namespace, currentLanguage, loadedTranslations);
+        if (!cancelled) {
+          setLoadedLanguage(currentLanguage);
+          setIsLoading(false);
+          setError(null);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setIsLoading(false);
+        }
+      }
+    };
+    loadTranslations();
+    return () => {
+      cancelled = true;
+    };
+  }, [screensetId, screenId, loader, i18nRegistry2, currentLanguage, loadedLanguage]);
+  const isLoaded = currentLanguage !== null && currentLanguage === loadedLanguage && !isLoading;
+  return { isLoaded, error };
+}
+
+// src/hooks/useFormatters.ts
+var import_react6 = require("react");
+var import_framework2 = require("@gears-frontx/framework");
+function useFormatters() {
+  const { language } = useTranslation();
+  return (0, import_react6.useMemo)(
+    () => {
+      void language;
+      return {
+        formatDate: import_framework2.formatDate,
+        formatTime: import_framework2.formatTime,
+        formatDateTime: import_framework2.formatDateTime,
+        formatRelative: import_framework2.formatRelative,
+        formatNumber: import_framework2.formatNumber,
+        formatPercent: import_framework2.formatPercent,
+        formatCompact: import_framework2.formatCompact,
+        formatCurrency: import_framework2.formatCurrency,
+        compareStrings: import_framework2.compareStrings,
+        createCollator: import_framework2.createCollator
+      };
+    },
+    [language]
+  );
+}
+
+// src/hooks/useTheme.ts
+var import_react7 = require("react");
+function useTheme() {
+  const app = useHAI3();
+  const { themeRegistry } = app;
+  const version = (0, import_react7.useSyncExternalStore)(
+    (0, import_react7.useCallback)(
+      (callback) => {
+        return themeRegistry.subscribe(callback);
+      },
+      [themeRegistry]
+    ),
+    () => themeRegistry.getVersion(),
+    () => themeRegistry.getVersion()
+  );
+  const currentTheme = (0, import_react7.useMemo)(() => {
+    void version;
+    const theme = themeRegistry.getCurrent();
+    return theme?.id;
+  }, [themeRegistry, version]);
+  const themes2 = (0, import_react7.useMemo)(() => {
+    return themeRegistry.getAll().map((theme) => ({
+      id: theme.id,
+      name: theme.name
+    }));
+  }, [themeRegistry]);
+  const setTheme = (0, import_react7.useCallback)(
+    (themeId) => {
+      if (app.actions.changeTheme) {
+        app.actions.changeTheme({ themeId });
+      }
+    },
+    [app.actions]
+  );
+  return {
+    currentTheme,
+    themes: themes2,
+    setTheme
+  };
+}
+
+// src/mfe/hooks/useMfeBridge.ts
+function useMfeBridge() {
+  const { bridge } = useMfeContext();
+  return bridge;
+}
+
+// src/mfe/hooks/useSharedProperty.ts
+var import_react8 = require("react");
+function useSharedProperty(propertyTypeId) {
+  const { bridge } = useMfeContext();
+  const subscribe = (0, import_react8.useCallback)((callback) => {
+    return bridge.subscribeToProperty(propertyTypeId, () => {
+      callback();
+    });
+  }, [bridge, propertyTypeId]);
+  const getSnapshot = (0, import_react8.useCallback)(() => {
+    const property = bridge.getProperty(propertyTypeId);
+    return property?.value;
+  }, [bridge, propertyTypeId]);
+  const value = (0, import_react8.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  return value;
+}
+
+// src/mfe/hooks/useHostAction.ts
+var import_react9 = require("react");
+function useHostAction(actionTypeId) {
+  const { bridge } = useMfeContext();
+  return (0, import_react9.useCallback)((payload) => {
+    const chain = {
+      action: {
+        type: actionTypeId,
+        target: bridge.domainId,
+        payload
+      }
+    };
+    bridge.executeActionsChain(chain).catch((error) => {
+      console.error(
+        `[useHostAction] Failed to send action '${actionTypeId}':`,
+        error
+      );
+    });
+  }, [actionTypeId, bridge]);
+}
+
+// src/mfe/hooks/useDomainExtensions.ts
+var import_react10 = require("react");
+function useDomainExtensions(domainId) {
+  const app = useHAI3();
+  const registry = app.screensetsRegistry;
+  if (!registry) {
+    throw new Error(
+      "useDomainExtensions requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+    );
+  }
+  const subscribe = (0, import_react10.useCallback)(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = (0, import_react10.useRef)({ ids: "", extensions: [] });
+  const getSnapshot = (0, import_react10.useCallback)(() => {
+    const extensions = registry.getExtensionsForDomain(domainId);
+    const ids = extensions.map((e) => e.id).join(",");
+    if (ids !== cacheRef.current.ids) {
+      cacheRef.current = { ids, extensions };
+    }
+    return cacheRef.current.extensions;
+  }, [registry, domainId]);
+  return (0, import_react10.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/hooks/useRegisteredPackages.ts
+var import_react11 = require("react");
+function useRegisteredPackages() {
+  const app = useHAI3();
+  const registry = app.screensetsRegistry;
+  if (!registry) {
+    throw new Error(
+      "useRegisteredPackages requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+    );
+  }
+  const subscribe = (0, import_react11.useCallback)(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = (0, import_react11.useRef)({ packages: "", list: [] });
+  const getSnapshot = (0, import_react11.useCallback)(() => {
+    const list = registry.getRegisteredPackages();
+    const packages = list.join(",");
+    if (packages !== cacheRef.current.packages) {
+      cacheRef.current = { packages, list };
+    }
+    return cacheRef.current.list;
+  }, [registry]);
+  return (0, import_react11.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/hooks/useActivePackage.ts
+var import_react12 = require("react");
+var import_framework3 = require("@gears-frontx/framework");
+function useActivePackage() {
+  const app = useHAI3();
+  const registry = app.screensetsRegistry;
+  if (!registry) {
+    throw new Error(
+      "useActivePackage requires the microfrontends plugin. Add microfrontends() to your HAI3 app configuration."
+    );
+  }
+  const subscribe = (0, import_react12.useCallback)(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = (0, import_react12.useRef)({ activePackage: void 0 });
+  const getSnapshot = (0, import_react12.useCallback)(() => {
+    const mountedExtensionId = registry.getMountedExtension(import_framework3.FRONTX_SCREEN_DOMAIN);
+    if (!mountedExtensionId) {
+      const result = void 0;
+      if (result !== cacheRef.current.activePackage) {
+        cacheRef.current = { activePackage: result };
+      }
+      return cacheRef.current.activePackage;
+    }
+    const activePackage = (0, import_framework3.extractGtsPackage)(mountedExtensionId);
+    if (activePackage !== cacheRef.current.activePackage) {
+      cacheRef.current = { activePackage };
+    }
+    return cacheRef.current.activePackage;
+  }, [registry]);
+  return (0, import_react12.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/components/RefContainerProvider.ts
+var import_framework4 = require("@gears-frontx/framework");
+var RefContainerProvider = class extends import_framework4.ContainerProvider {
+  constructor(containerRef) {
+    super();
+    this.containerRef = containerRef;
+  }
+  getContainer(_extensionId) {
+    if (!this.containerRef.current) {
+      throw new Error("Container ref is not attached -- component may not be mounted yet");
+    }
+    return this.containerRef.current;
+  }
+  releaseContainer(_extensionId) {
+  }
+};
+
+// src/mfe/components/ExtensionDomainSlot.tsx
+var import_react13 = require("react");
+var import_framework5 = require("@gears-frontx/framework");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function ExtensionDomainSlot(props) {
+  const {
+    registry,
+    domainId,
+    extensionId,
+    className,
+    onMounted,
+    onUnmounted,
+    onError,
+    loadingComponent,
+    errorComponent
+  } = props;
+  const containerRef = (0, import_react13.useRef)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const [bridge, setBridge] = (0, import_react13.useState)(null);
+  (0, import_react13.useEffect)(() => {
+    let mounted = true;
+    let currentBridge = null;
+    async function mountExtension2() {
+      if (!containerRef.current) {
+        return;
+      }
+      try {
+        setIsLoading(true);
+        setError(null);
+        await registry.executeActionsChain({
+          action: {
+            type: import_framework5.FRONTX_ACTION_MOUNT_EXT,
+            target: domainId,
+            payload: {
+              extensionId
+            }
+          }
+        });
+        if (!mounted) {
+          await registry.executeActionsChain({
+            action: {
+              type: import_framework5.FRONTX_ACTION_UNMOUNT_EXT,
+              target: domainId,
+              payload: {
+                extensionId
+              }
+            }
+          });
+          return;
+        }
+        const newBridge = registry.getParentBridge(extensionId);
+        if (!newBridge) {
+          throw new Error(`Failed to obtain bridge for extension ${extensionId} after mount`);
+        }
+        currentBridge = newBridge;
+        setBridge(newBridge);
+        setIsLoading(false);
+        if (onMounted) {
+          onMounted(newBridge);
+        }
+      } catch (err) {
+        if (!mounted) {
+          return;
+        }
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        setError(errorObj);
+        setIsLoading(false);
+        if (onError) {
+          onError(errorObj);
+        }
+      }
+    }
+    void mountExtension2();
+    return () => {
+      mounted = false;
+      if (currentBridge) {
+        void registry.executeActionsChain({
+          action: {
+            type: import_framework5.FRONTX_ACTION_UNMOUNT_EXT,
+            target: domainId,
+            payload: {
+              extensionId
+            }
+          }
+        }).then(() => {
+          if (onUnmounted) {
+            onUnmounted();
+          }
+        });
+      }
+    };
+  }, [registry, domainId, extensionId, onMounted, onUnmounted, onError]);
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: loadingComponent ?? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { children: "Loading extension..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: errorComponent ? errorComponent(error) : /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("strong", { children: "Error loading extension:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { children: error.message })
+    ] }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      "data-domain-id": domainId,
+      "data-extension-id": extensionId,
+      "data-bridge-active": bridge !== null
+    }
+  );
+}
+
+// src/index.ts
+var import_framework6 = require("@gears-frontx/framework");
+var import_framework7 = require("@gears-frontx/framework");
+var import_framework8 = require("@gears-frontx/framework");
+var import_framework9 = require("@gears-frontx/framework");
+var import_framework10 = require("@gears-frontx/framework");
+var import_framework11 = require("@gears-frontx/framework");
+var import_framework12 = require("@gears-frontx/framework");
+var import_framework13 = require("@gears-frontx/framework");
+var import_framework14 = require("@gears-frontx/framework");
+var import_framework15 = require("@gears-frontx/framework");
+var import_framework16 = require("@gears-frontx/framework");
+var import_framework17 = require("@gears-frontx/framework");
+var import_framework18 = require("@gears-frontx/framework");
+var import_framework19 = require("@gears-frontx/framework");
+var eventBus = import_framework19.eventBus;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCOUNTS_DOMAIN,
+  ApiPlugin,
+  ApiPluginBase,
+  ApiProtocol,
+  BaseApiService,
+  ContainerProvider,
+  ExtensionDomainSlot,
+  FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT,
+  FRONTX_MFE_ENTRY_MF,
+  FRONTX_OVERLAY_DOMAIN,
+  FRONTX_POPUP_DOMAIN,
+  FRONTX_SCREEN_DOMAIN,
+  FRONTX_SCREEN_EXTENSION_TYPE,
+  FRONTX_SHARED_PROPERTY_LANGUAGE,
+  FRONTX_SHARED_PROPERTY_THEME,
+  FRONTX_SIDEBAR_DOMAIN,
+  HAI3Context,
+  HAI3Provider,
+  I18nRegistry,
+  I18nRegistryImpl,
+  LAYOUT_SLICE_NAME,
+  Language,
+  LanguageDisplayMode,
+  LayoutDomain,
+  MOCK_PLUGIN,
+  MfeBridgeFactory,
+  MfeContext,
+  MfeHandler,
+  MfeHandlerMF,
+  MfeProvider,
+  MockEventSource,
+  MockEvents,
+  RefContainerProvider,
+  RestMockPlugin,
+  RestPlugin,
+  RestPluginWithConfig,
+  RestProtocol,
+  SUPPORTED_LANGUAGES,
+  ScreensetsRegistry,
+  ScreensetsRegistryFactory,
+  SseMockPlugin,
+  SsePlugin,
+  SsePluginWithConfig,
+  SseProtocol,
+  TENANT_SLICE_NAME,
+  TenantEvents,
+  TextDirection,
+  apiRegistry,
+  changeTenant,
+  clearActiveScreen,
+  clearTenant,
+  clearTenantAction,
+  clearUser,
+  closeAllPopups,
+  closePopup,
+  closeTopPopup,
+  createHAI3,
+  createHAI3App,
+  createI18nRegistry,
+  createShadowRoot,
+  createSlice,
+  createStore,
+  createThemeRegistry,
+  effects,
+  eventBus,
+  extensionScreenSchema,
+  extractGtsPackage,
+  footerActions,
+  footerSlice,
+  getLanguageMetadata,
+  getStore,
+  gtsPlugin,
+  hasSlice,
+  headerActions,
+  headerSlice,
+  hideOverlay,
+  i18n,
+  i18nRegistry,
+  initMockEffects,
+  initTenantEffects,
+  injectCssVariables,
+  isMockPlugin,
+  isRestShortCircuit,
+  isShortCircuit,
+  isSseShortCircuit,
+  languageSchema,
+  layout,
+  layoutDomainReducers,
+  layoutReducer,
+  loadExtension,
+  menuActions,
+  menuSlice,
+  microfrontends,
+  mock,
+  mockActions,
+  mockSlice,
+  mountExtension,
+  navigateTo,
+  openPopup,
+  overlayActions,
+  overlayDomain,
+  overlaySlice,
+  popupActions,
+  popupDomain,
+  popupSlice,
+  presets,
+  registerExtension,
+  registerSlice,
+  screenActions,
+  screenDomain,
+  screenSlice,
+  screensets,
+  screensetsRegistryFactory,
+  selectExtensionError,
+  selectExtensionState,
+  selectRegisteredExtensions,
+  setActiveScreen,
+  setFooterConfig,
+  setFooterVisible,
+  setHeaderLoading,
+  setMenuCollapsed,
+  setMenuConfig,
+  setMenuItems,
+  setMenuVisible,
+  setMockEnabled,
+  setOverlayVisible,
+  setScreenLoading,
+  setSidebarCollapsed,
+  setSidebarConfig,
+  setSidebarContent,
+  setSidebarPosition,
+  setSidebarTitle,
+  setSidebarVisible,
+  setSidebarWidth,
+  setTenant,
+  setTenantLoading,
+  setTenantLoadingState,
+  setUser,
+  showOverlay,
+  sidebarActions,
+  sidebarDomain,
+  sidebarSlice,
+  tenantActions,
+  tenantReducer,
+  tenantSlice,
+  themeSchema,
+  themes,
+  toggleMenu,
+  toggleMockMode,
+  toggleSidebar,
+  unmountExtension,
+  unregisterExtension,
+  useActivePackage,
+  useAppDispatch,
+  useAppSelector,
+  useDomainExtensions,
+  useFormatters,
+  useHAI3,
+  useHostAction,
+  useMfeBridge,
+  useMfeContext,
+  useRegisteredPackages,
+  useScreenTranslations,
+  useSharedProperty,
+  useTheme,
+  useTranslation
+});
+//# sourceMappingURL=index.cjs.map