@gears-frontx/react 0.1.0

package/dist/index.js

@@ -0,0 +1,872 @@
+// src/HAI3Provider.tsx
+import { useMemo, useEffect } from "react";
+import { Provider as ReduxProvider } from "react-redux";
+import { createHAI3App } from "@gears-frontx/framework";
+
+// src/HAI3Context.tsx
+import { createContext, useContext } from "react";
+var HAI3Context = createContext(null);
+function useHAI3() {
+  const context = 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
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var MfeContext = createContext2(null);
+function useMfeContext() {
+  const context = useContext2(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
+import { jsx } from "react/jsx-runtime";
+var MfeProvider = ({ value, children }) => {
+  return /* @__PURE__ */ jsx(MfeContext.Provider, { value, children });
+};
+
+// src/HAI3Provider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var HAI3Provider = ({
+  children,
+  config,
+  app: providedApp,
+  mfeBridge
+}) => {
+  const app = useMemo(() => {
+    if (providedApp) {
+      return providedApp;
+    }
+    return createHAI3App(config);
+  }, [providedApp, config]);
+  useEffect(() => {
+    return () => {
+      if (!providedApp) {
+        app.destroy();
+      }
+    };
+  }, [app, providedApp]);
+  const content = /* @__PURE__ */ jsx2(HAI3Context.Provider, { value: app, children: /* @__PURE__ */ jsx2(ReduxProvider, { store: app.store, children }) });
+  if (mfeBridge) {
+    return /* @__PURE__ */ jsx2(MfeProvider, { value: mfeBridge, children: content });
+  }
+  return content;
+};
+
+// src/hooks/useAppDispatch.ts
+import { useDispatch } from "react-redux";
+function useAppDispatch() {
+  return useDispatch();
+}
+
+// src/hooks/useAppSelector.ts
+import { useSelector } from "react-redux";
+var useAppSelector = useSelector;
+
+// src/hooks/useTranslation.ts
+import { useMemo as useMemo2, useCallback, useSyncExternalStore } from "react";
+function useTranslation() {
+  const app = useHAI3();
+  const { i18nRegistry: i18nRegistry2 } = app;
+  const version = useSyncExternalStore(
+    useCallback(
+      (callback) => {
+        return i18nRegistry2.subscribe(callback);
+      },
+      [i18nRegistry2]
+    ),
+    () => i18nRegistry2.getVersion(),
+    () => i18nRegistry2.getVersion()
+  );
+  const language = useMemo2(() => {
+    void version;
+    return i18nRegistry2.getLanguage();
+  }, [i18nRegistry2, version]);
+  const t = useCallback(
+    (key, params) => {
+      return i18nRegistry2.t(key, params);
+    },
+    [i18nRegistry2]
+  );
+  const setLanguage = useCallback(
+    (lang) => {
+      if (app.actions.setLanguage) {
+        app.actions.setLanguage({ language: lang });
+      }
+    },
+    [app.actions]
+  );
+  const isRTL = useMemo2(() => {
+    void language;
+    return i18nRegistry2.isRTL();
+  }, [i18nRegistry2, language]);
+  return {
+    t,
+    language,
+    setLanguage,
+    isRTL
+  };
+}
+
+// src/hooks/useScreenTranslations.ts
+import { useState, useEffect as useEffect2, useMemo as useMemo3, useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore2 } from "react";
+function isTranslationLoader(input) {
+  return typeof input === "function";
+}
+function useScreenTranslations(screensetId, screenId, translations) {
+  const app = useHAI3();
+  const { i18nRegistry: i18nRegistry2 } = app;
+  const [loadedLanguage, setLoadedLanguage] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const version = useSyncExternalStore2(
+    useCallback2(
+      (callback) => i18nRegistry2.subscribe(callback),
+      [i18nRegistry2]
+    ),
+    () => i18nRegistry2.getVersion(),
+    () => i18nRegistry2.getVersion()
+  );
+  const currentLanguage = useMemo3(() => {
+    void version;
+    return i18nRegistry2.getLanguage();
+  }, [i18nRegistry2, version]);
+  const loader = useMemo3(() => {
+    if (isTranslationLoader(translations)) {
+      return translations;
+    }
+    return async (language) => {
+      const importFn = translations[language];
+      if (!importFn) {
+        return {};
+      }
+      const module = await importFn();
+      return module.default;
+    };
+  }, [translations]);
+  useEffect2(() => {
+    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
+import { useMemo as useMemo4 } from "react";
+import {
+  formatDate as formatDateFn,
+  formatTime as formatTimeFn,
+  formatDateTime as formatDateTimeFn,
+  formatRelative as formatRelativeFn,
+  formatNumber as formatNumberFn,
+  formatPercent as formatPercentFn,
+  formatCompact as formatCompactFn,
+  formatCurrency as formatCurrencyFn,
+  compareStrings as compareStringsFn,
+  createCollator as createCollatorFn
+} from "@gears-frontx/framework";
+function useFormatters() {
+  const { language } = useTranslation();
+  return useMemo4(
+    () => {
+      void language;
+      return {
+        formatDate: formatDateFn,
+        formatTime: formatTimeFn,
+        formatDateTime: formatDateTimeFn,
+        formatRelative: formatRelativeFn,
+        formatNumber: formatNumberFn,
+        formatPercent: formatPercentFn,
+        formatCompact: formatCompactFn,
+        formatCurrency: formatCurrencyFn,
+        compareStrings: compareStringsFn,
+        createCollator: createCollatorFn
+      };
+    },
+    [language]
+  );
+}
+
+// src/hooks/useTheme.ts
+import { useCallback as useCallback3, useMemo as useMemo5, useSyncExternalStore as useSyncExternalStore3 } from "react";
+function useTheme() {
+  const app = useHAI3();
+  const { themeRegistry } = app;
+  const version = useSyncExternalStore3(
+    useCallback3(
+      (callback) => {
+        return themeRegistry.subscribe(callback);
+      },
+      [themeRegistry]
+    ),
+    () => themeRegistry.getVersion(),
+    () => themeRegistry.getVersion()
+  );
+  const currentTheme = useMemo5(() => {
+    void version;
+    const theme = themeRegistry.getCurrent();
+    return theme?.id;
+  }, [themeRegistry, version]);
+  const themes2 = useMemo5(() => {
+    return themeRegistry.getAll().map((theme) => ({
+      id: theme.id,
+      name: theme.name
+    }));
+  }, [themeRegistry]);
+  const setTheme = useCallback3(
+    (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
+import { useSyncExternalStore as useSyncExternalStore4, useCallback as useCallback4 } from "react";
+function useSharedProperty(propertyTypeId) {
+  const { bridge } = useMfeContext();
+  const subscribe = useCallback4((callback) => {
+    return bridge.subscribeToProperty(propertyTypeId, () => {
+      callback();
+    });
+  }, [bridge, propertyTypeId]);
+  const getSnapshot = useCallback4(() => {
+    const property = bridge.getProperty(propertyTypeId);
+    return property?.value;
+  }, [bridge, propertyTypeId]);
+  const value = useSyncExternalStore4(subscribe, getSnapshot, getSnapshot);
+  return value;
+}
+
+// src/mfe/hooks/useHostAction.ts
+import { useCallback as useCallback5 } from "react";
+function useHostAction(actionTypeId) {
+  const { bridge } = useMfeContext();
+  return useCallback5((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
+import { useSyncExternalStore as useSyncExternalStore5, useCallback as useCallback6, useRef } from "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 = useCallback6(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = useRef({ ids: "", extensions: [] });
+  const getSnapshot = useCallback6(() => {
+    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 useSyncExternalStore5(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/hooks/useRegisteredPackages.ts
+import { useSyncExternalStore as useSyncExternalStore6, useCallback as useCallback7, useRef as useRef2 } from "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 = useCallback7(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = useRef2({ packages: "", list: [] });
+  const getSnapshot = useCallback7(() => {
+    const list = registry.getRegisteredPackages();
+    const packages = list.join(",");
+    if (packages !== cacheRef.current.packages) {
+      cacheRef.current = { packages, list };
+    }
+    return cacheRef.current.list;
+  }, [registry]);
+  return useSyncExternalStore6(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/hooks/useActivePackage.ts
+import { useSyncExternalStore as useSyncExternalStore7, useCallback as useCallback8, useRef as useRef3 } from "react";
+import { extractGtsPackage, FRONTX_SCREEN_DOMAIN } from "@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 = useCallback8(
+    (onStoreChange) => {
+      return app.store.subscribe(onStoreChange);
+    },
+    [app.store]
+  );
+  const cacheRef = useRef3({ activePackage: void 0 });
+  const getSnapshot = useCallback8(() => {
+    const mountedExtensionId = registry.getMountedExtension(FRONTX_SCREEN_DOMAIN);
+    if (!mountedExtensionId) {
+      const result = void 0;
+      if (result !== cacheRef.current.activePackage) {
+        cacheRef.current = { activePackage: result };
+      }
+      return cacheRef.current.activePackage;
+    }
+    const activePackage = extractGtsPackage(mountedExtensionId);
+    if (activePackage !== cacheRef.current.activePackage) {
+      cacheRef.current = { activePackage };
+    }
+    return cacheRef.current.activePackage;
+  }, [registry]);
+  return useSyncExternalStore7(subscribe, getSnapshot, getSnapshot);
+}
+
+// src/mfe/components/RefContainerProvider.ts
+import { ContainerProvider } from "@gears-frontx/framework";
+var RefContainerProvider = class extends 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
+import { useEffect as useEffect3, useRef as useRef4, useState as useState2 } from "react";
+import {
+  FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT
+} from "@gears-frontx/framework";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function ExtensionDomainSlot(props) {
+  const {
+    registry,
+    domainId,
+    extensionId,
+    className,
+    onMounted,
+    onUnmounted,
+    onError,
+    loadingComponent,
+    errorComponent
+  } = props;
+  const containerRef = useRef4(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [bridge, setBridge] = useState2(null);
+  useEffect3(() => {
+    let mounted = true;
+    let currentBridge = null;
+    async function mountExtension2() {
+      if (!containerRef.current) {
+        return;
+      }
+      try {
+        setIsLoading(true);
+        setError(null);
+        await registry.executeActionsChain({
+          action: {
+            type: FRONTX_ACTION_MOUNT_EXT,
+            target: domainId,
+            payload: {
+              extensionId
+            }
+          }
+        });
+        if (!mounted) {
+          await registry.executeActionsChain({
+            action: {
+              type: 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: FRONTX_ACTION_UNMOUNT_EXT,
+            target: domainId,
+            payload: {
+              extensionId
+            }
+          }
+        }).then(() => {
+          if (onUnmounted) {
+            onUnmounted();
+          }
+        });
+      }
+    };
+  }, [registry, domainId, extensionId, onMounted, onUnmounted, onError]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsx3("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: loadingComponent ?? /* @__PURE__ */ jsx3("div", { children: "Loading extension..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx3("div", { className, "data-domain-id": domainId, "data-extension-id": extensionId, children: errorComponent ? errorComponent(error) : /* @__PURE__ */ jsxs("div", { children: [
+      /* @__PURE__ */ jsx3("strong", { children: "Error loading extension:" }),
+      /* @__PURE__ */ jsx3("pre", { children: error.message })
+    ] }) });
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      "data-domain-id": domainId,
+      "data-extension-id": extensionId,
+      "data-bridge-active": bridge !== null
+    }
+  );
+}
+
+// src/index.ts
+import {
+  createHAI3,
+  createHAI3App as createHAI3App2,
+  presets,
+  ACCOUNTS_DOMAIN,
+  I18nRegistry,
+  screensets,
+  themes,
+  layout,
+  i18n,
+  effects,
+  createThemeRegistry,
+  createStore,
+  getStore,
+  registerSlice,
+  hasSlice,
+  createSlice,
+  LayoutDomain,
+  layoutReducer,
+  layoutDomainReducers,
+  LAYOUT_SLICE_NAME,
+  headerSlice,
+  footerSlice,
+  menuSlice,
+  sidebarSlice,
+  screenSlice,
+  popupSlice,
+  overlaySlice,
+  headerActions,
+  footerActions,
+  menuActions,
+  sidebarActions,
+  screenActions,
+  popupActions,
+  overlayActions,
+  setUser,
+  setHeaderLoading,
+  clearUser,
+  setFooterVisible,
+  setFooterConfig,
+  toggleMenu,
+  setMenuCollapsed,
+  setMenuItems,
+  setMenuVisible,
+  setMenuConfig,
+  toggleSidebar,
+  setSidebarCollapsed,
+  setSidebarPosition,
+  setSidebarTitle,
+  setSidebarContent,
+  setSidebarVisible,
+  setSidebarWidth,
+  setSidebarConfig,
+  setActiveScreen,
+  setScreenLoading,
+  navigateTo,
+  clearActiveScreen,
+  openPopup,
+  closePopup,
+  closeTopPopup,
+  closeAllPopups,
+  showOverlay,
+  hideOverlay,
+  setOverlayVisible,
+  TENANT_SLICE_NAME,
+  tenantSlice,
+  tenantActions,
+  tenantReducer,
+  setTenant,
+  setTenantLoading,
+  clearTenant,
+  initTenantEffects,
+  changeTenant,
+  clearTenantAction,
+  setTenantLoadingState,
+  TenantEvents,
+  mockSlice,
+  mockActions,
+  setMockEnabled,
+  initMockEffects,
+  toggleMockMode,
+  MockEvents,
+  apiRegistry,
+  BaseApiService,
+  RestProtocol,
+  SseProtocol,
+  RestMockPlugin,
+  SseMockPlugin,
+  MockEventSource,
+  ApiPluginBase,
+  ApiPlugin,
+  ApiProtocol,
+  RestPlugin,
+  RestPluginWithConfig,
+  SsePlugin,
+  SsePluginWithConfig,
+  isShortCircuit,
+  isRestShortCircuit,
+  isSseShortCircuit,
+  MOCK_PLUGIN,
+  isMockPlugin,
+  i18nRegistry,
+  I18nRegistryImpl,
+  createI18nRegistry,
+  SUPPORTED_LANGUAGES,
+  getLanguageMetadata
+} from "@gears-frontx/framework";
+import { Language, TextDirection, LanguageDisplayMode } from "@gears-frontx/framework";
+import {
+  microfrontends,
+  mock
+} from "@gears-frontx/framework";
+import {
+  loadExtension,
+  mountExtension,
+  unmountExtension,
+  registerExtension,
+  unregisterExtension
+} from "@gears-frontx/framework";
+import {
+  selectExtensionState,
+  selectRegisteredExtensions,
+  selectExtensionError
+} from "@gears-frontx/framework";
+import {
+  FRONTX_POPUP_DOMAIN,
+  FRONTX_SIDEBAR_DOMAIN,
+  FRONTX_SCREEN_DOMAIN as FRONTX_SCREEN_DOMAIN2,
+  FRONTX_OVERLAY_DOMAIN,
+  screenDomain,
+  sidebarDomain,
+  popupDomain,
+  overlayDomain
+} from "@gears-frontx/framework";
+import {
+  FRONTX_SCREEN_EXTENSION_TYPE,
+  FRONTX_MFE_ENTRY_MF
+} from "@gears-frontx/framework";
+import {
+  FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT as FRONTX_ACTION_MOUNT_EXT2,
+  FRONTX_ACTION_UNMOUNT_EXT as FRONTX_ACTION_UNMOUNT_EXT2
+} from "@gears-frontx/framework";
+import {
+  FRONTX_SHARED_PROPERTY_THEME,
+  FRONTX_SHARED_PROPERTY_LANGUAGE
+} from "@gears-frontx/framework";
+import {
+  MfeHandler,
+  MfeBridgeFactory,
+  ScreensetsRegistry,
+  ScreensetsRegistryFactory,
+  screensetsRegistryFactory,
+  ContainerProvider as ContainerProvider2
+} from "@gears-frontx/framework";
+import { MfeHandlerMF, gtsPlugin } from "@gears-frontx/framework";
+import { themeSchema, languageSchema, extensionScreenSchema } from "@gears-frontx/framework";
+import {
+  createShadowRoot,
+  injectCssVariables,
+  extractGtsPackage as extractGtsPackage2
+} from "@gears-frontx/framework";
+import { eventBus as frameworkEventBus } from "@gears-frontx/framework";
+var eventBus = frameworkEventBus;
+export {
+  ACCOUNTS_DOMAIN,
+  ApiPlugin,
+  ApiPluginBase,
+  ApiProtocol,
+  BaseApiService,
+  ContainerProvider2 as ContainerProvider,
+  ExtensionDomainSlot,
+  FRONTX_ACTION_LOAD_EXT,
+  FRONTX_ACTION_MOUNT_EXT2 as FRONTX_ACTION_MOUNT_EXT,
+  FRONTX_ACTION_UNMOUNT_EXT2 as FRONTX_ACTION_UNMOUNT_EXT,
+  FRONTX_MFE_ENTRY_MF,
+  FRONTX_OVERLAY_DOMAIN,
+  FRONTX_POPUP_DOMAIN,
+  FRONTX_SCREEN_DOMAIN2 as 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,
+  createHAI3App2 as createHAI3App,
+  createI18nRegistry,
+  createShadowRoot,
+  createSlice,
+  createStore,
+  createThemeRegistry,
+  effects,
+  eventBus,
+  extensionScreenSchema,
+  extractGtsPackage2 as 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.js.map