@hai3/framework 0.2.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1397 @@
+"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: () => ACCOUNTS_DOMAIN,
+  BaseApiService: () => import_api3.BaseApiService,
+  I18nRegistry: () => import_i18n6.I18nRegistryImpl,
+  I18nRegistryImpl: () => import_i18n5.I18nRegistryImpl,
+  LAYOUT_SLICE_NAME: () => LAYOUT_SLICE_NAME,
+  Language: () => import_i18n5.Language,
+  LanguageDisplayMode: () => import_i18n5.LanguageDisplayMode,
+  LayoutDomain: () => import_screensets7.LayoutDomain,
+  MockPlugin: () => import_api3.MockPlugin,
+  RestProtocol: () => import_api3.RestProtocol,
+  STATE_PATH_MAPPING: () => STATE_PATH_MAPPING,
+  SUPPORTED_LANGUAGES: () => import_i18n5.SUPPORTED_LANGUAGES,
+  ScreensetCategory: () => import_screensets7.ScreensetCategory,
+  SseProtocol: () => import_api3.SseProtocol,
+  TENANT_SLICE_NAME: () => TENANT_SLICE_NAME,
+  TenantEvents: () => TenantEvents,
+  TextDirection: () => import_i18n5.TextDirection,
+  apiRegistry: () => import_api3.apiRegistry,
+  changeTenant: () => changeTenant,
+  clearActiveScreen: () => clearActiveScreen,
+  clearTenant: () => clearTenant,
+  clearTenantAction: () => clearTenantAction,
+  clearUser: () => clearUser,
+  closeAllPopups: () => closeAllPopups,
+  closePopup: () => closePopup,
+  closeTopPopup: () => closeTopPopup,
+  createHAI3: () => createHAI3,
+  createHAI3App: () => createHAI3App,
+  createI18nRegistry: () => import_i18n5.createI18nRegistry,
+  createLegacySelector: () => createLegacySelector,
+  createRouteRegistry: () => createRouteRegistry,
+  createScreensetRegistry: () => import_screensets6.createScreensetRegistry,
+  createSlice: () => import_state16.createSlice,
+  createStore: () => import_state16.createStore,
+  createThemeRegistry: () => createThemeRegistry,
+  effects: () => effects,
+  eventBus: () => import_state16.eventBus,
+  fetchCurrentUser: () => fetchCurrentUser,
+  footerActions: () => footerActions,
+  footerSlice: () => footerSlice,
+  full: () => full,
+  getLanguageMetadata: () => import_i18n5.getLanguageMetadata,
+  getLayoutDomainState: () => getLayoutDomainState,
+  getStore: () => import_state16.getStore,
+  hasLegacyUicoreState: () => hasLegacyUicoreState,
+  hasNewLayoutState: () => hasNewLayoutState,
+  hasSlice: () => import_state16.hasSlice,
+  headerActions: () => headerActions,
+  headerSlice: () => headerSlice,
+  headless: () => headless,
+  hideOverlay: () => hideOverlay,
+  i18n: () => i18n,
+  i18nRegistry: () => import_i18n5.i18nRegistry,
+  initTenantEffects: () => initTenantEffects,
+  isDeprecationWarningsEnabled: () => isDeprecationWarningsEnabled,
+  layout: () => layout,
+  layoutDomainReducers: () => layoutDomainReducers,
+  layoutReducer: () => layoutReducer,
+  legacySelectors: () => legacySelectors,
+  menuActions: () => menuActions,
+  menuSlice: () => menuSlice,
+  minimal: () => minimal,
+  navigateTo: () => navigateTo,
+  navigateToScreen: () => navigateToScreen,
+  navigation: () => navigation,
+  openPopup: () => openPopup,
+  overlayActions: () => overlayActions,
+  overlaySlice: () => overlaySlice,
+  popupActions: () => popupActions,
+  popupSlice: () => popupSlice,
+  presets: () => presets,
+  registerSlice: () => import_state16.registerSlice,
+  routeRegistry: () => routeRegistry,
+  routing: () => routing,
+  screenActions: () => screenActions,
+  screenSlice: () => screenSlice,
+  screensetRegistry: () => import_screensets3.screensetRegistry,
+  screensets: () => screensets,
+  setActiveScreen: () => setActiveScreen,
+  setDeprecationWarnings: () => setDeprecationWarnings,
+  setFooterConfig: () => setFooterConfig,
+  setFooterVisible: () => setFooterVisible,
+  setHeaderLoading: () => setLoading,
+  setMenuCollapsed: () => setMenuCollapsed,
+  setMenuConfig: () => setMenuConfig,
+  setMenuItems: () => setMenuItems,
+  setMenuVisible: () => setMenuVisible,
+  setOverlayVisible: () => setOverlayVisible,
+  setScreenLoading: () => setScreenLoading,
+  setSidebarCollapsed: () => setSidebarCollapsed,
+  setSidebarConfig: () => setSidebarConfig,
+  setSidebarContent: () => setSidebarContent,
+  setSidebarPosition: () => setSidebarPosition,
+  setSidebarTitle: () => setSidebarTitle,
+  setSidebarVisible: () => setSidebarVisible,
+  setSidebarWidth: () => setSidebarWidth,
+  setTenant: () => setTenant,
+  setTenantLoading: () => setTenantLoading,
+  setTenantLoadingState: () => setTenantLoadingState,
+  setUser: () => setUser,
+  showOverlay: () => showOverlay,
+  sidebarActions: () => sidebarActions,
+  sidebarSlice: () => sidebarSlice,
+  tenantActions: () => tenantActions,
+  tenantReducer: () => tenantSlice_default,
+  tenantSlice: () => tenantSlice,
+  themeRegistry: () => themeRegistry,
+  themes: () => themes,
+  toggleMenu: () => toggleMenu,
+  toggleSidebar: () => toggleSidebar
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/createHAI3.ts
+var import_state = require("@hai3/state");
+var import_api = require("@hai3/api");
+function isPluginFactory(value) {
+  return typeof value === "function";
+}
+function resolvePlugin(plugin) {
+  return isPluginFactory(plugin) ? plugin() : plugin;
+}
+var HAI3AppBuilderImpl = class {
+  plugins = [];
+  config;
+  constructor(config = {}) {
+    this.config = {
+      name: "HAI3 App",
+      devMode: false,
+      strictMode: false,
+      ...config
+    };
+  }
+  /**
+   * Add a plugin to the application.
+   * Also accepts an array of plugins (for preset support).
+   */
+  use(plugin) {
+    if (Array.isArray(plugin)) {
+      plugin.forEach((p) => this.use(p));
+      return this;
+    }
+    const resolved = resolvePlugin(plugin);
+    if (this.plugins.some((p) => p.name === resolved.name)) {
+      if (this.config.devMode) {
+        console.warn(
+          `Plugin "${resolved.name}" is already registered. Skipping duplicate.`
+        );
+      }
+      return this;
+    }
+    this.plugins.push(resolved);
+    return this;
+  }
+  /**
+   * Add multiple plugins at once.
+   */
+  useAll(plugins) {
+    plugins.forEach((plugin) => this.use(plugin));
+    return this;
+  }
+  /**
+   * Build the application.
+   */
+  build() {
+    const orderedPlugins = this.resolveDependencies();
+    orderedPlugins.forEach((plugin) => {
+      if (plugin.onRegister) {
+        plugin.onRegister(this, plugin._configType);
+      }
+    });
+    const aggregated = this.aggregateProvides(orderedPlugins);
+    const store = this.createStoreWithSlices(aggregated.slices);
+    aggregated.effects.forEach((initEffect) => {
+      initEffect(store.dispatch);
+    });
+    const app = {
+      config: this.config,
+      store,
+      screensetRegistry: aggregated.registries.screensetRegistry,
+      themeRegistry: aggregated.registries.themeRegistry,
+      routeRegistry: aggregated.registries.routeRegistry,
+      apiRegistry: import_api.apiRegistry,
+      i18nRegistry: aggregated.registries.i18nRegistry,
+      actions: aggregated.actions,
+      destroy: () => this.destroyApp(orderedPlugins, app)
+    };
+    orderedPlugins.forEach((plugin) => {
+      if (plugin.onInit) {
+        plugin.onInit(app);
+      }
+    });
+    return app;
+  }
+  /**
+   * Resolve plugin dependencies using topological sort.
+   */
+  resolveDependencies() {
+    const resolved = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (plugin) => {
+      if (visited.has(plugin.name)) return;
+      if (visiting.has(plugin.name)) {
+        throw new Error(
+          `Circular dependency detected: ${plugin.name} depends on itself or creates a cycle.`
+        );
+      }
+      visiting.add(plugin.name);
+      if (plugin.dependencies) {
+        for (const depName of plugin.dependencies) {
+          const dep = this.plugins.find((p) => p.name === depName);
+          if (!dep) {
+            if (this.config.strictMode) {
+              throw new Error(
+                `Plugin "${plugin.name}" requires "${depName}" but it is not registered.
+Add the missing plugin: .use(${depName}())`
+              );
+            } else {
+              console.warn(
+                `Plugin "${plugin.name}" requires "${depName}" but it is not registered. Some features may not work correctly.`
+              );
+              continue;
+            }
+          }
+          visit(dep);
+        }
+      }
+      visiting.delete(plugin.name);
+      visited.add(plugin.name);
+      resolved.push(plugin);
+    };
+    this.plugins.forEach(visit);
+    return resolved;
+  }
+  /**
+   * Aggregate all provides from plugins.
+   */
+  aggregateProvides(plugins) {
+    const registries = {};
+    const slices = [];
+    const effects2 = [];
+    const actions = {};
+    plugins.forEach((plugin) => {
+      if (!plugin.provides) return;
+      if (plugin.provides.registries) {
+        Object.assign(registries, plugin.provides.registries);
+      }
+      if (plugin.provides.slices) {
+        slices.push(...plugin.provides.slices);
+      }
+      if (plugin.provides.effects) {
+        effects2.push(...plugin.provides.effects);
+      }
+      if (plugin.provides.actions) {
+        Object.assign(actions, plugin.provides.actions);
+      }
+    });
+    return { registries, slices, effects: effects2, actions };
+  }
+  /**
+   * Create store with all aggregated slices.
+   *
+   * IMPORTANT: This method supports the screenset self-registration pattern.
+   * Screensets call registerSlice() as module side effects when imported,
+   * which may auto-create a store before createHAI3App() is called.
+   *
+   * This method:
+   * 1. Uses the existing store if one was auto-created by screensets
+   * 2. Registers framework slices to the existing store
+   * 3. Returns the unified store for HAI3App
+   */
+  createStoreWithSlices(slices) {
+    const store = (0, import_state.getStore)();
+    slices.forEach((slice9) => {
+      (0, import_state.registerSlice)(slice9);
+    });
+    return store;
+  }
+  /**
+   * Destroy the app and cleanup resources.
+   */
+  destroyApp(plugins, app) {
+    [...plugins].reverse().forEach((plugin) => {
+      if (plugin.onDestroy) {
+        plugin.onDestroy(app);
+      }
+    });
+  }
+};
+function createHAI3(config) {
+  return new HAI3AppBuilderImpl(config);
+}
+
+// src/plugins/screensets.ts
+var import_screensets = require("@hai3/screensets");
+
+// src/slices/index.ts
+var import_toolkit = require("@reduxjs/toolkit");
+
+// src/slices/headerSlice.ts
+var import_state2 = require("@hai3/state");
+var SLICE_KEY = "layout/header";
+var initialState = {
+  user: null,
+  loading: false
+};
+var { slice, setUser, setLoading, clearUser } = (0, import_state2.createSlice)({
+  name: SLICE_KEY,
+  initialState,
+  reducers: {
+    setUser: (state, action) => {
+      state.user = action.payload;
+      state.loading = false;
+    },
+    setLoading: (state, action) => {
+      state.loading = action.payload;
+    },
+    clearUser: (state) => {
+      state.user = null;
+      state.loading = false;
+    }
+  }
+});
+var headerSlice = slice;
+var headerActions = { setUser, setLoading, clearUser };
+var headerSlice_default = slice.reducer;
+
+// src/slices/footerSlice.ts
+var import_state3 = require("@hai3/state");
+var SLICE_KEY2 = "layout/footer";
+var initialState2 = {
+  screensetOptions: [],
+  visible: true
+};
+var { slice: slice2, setFooterVisible, setFooterConfig, ...restActions } = (0, import_state3.createSlice)({
+  name: SLICE_KEY2,
+  initialState: initialState2,
+  reducers: {
+    setFooterVisible: (state, action) => {
+      state.visible = action.payload;
+    },
+    setFooterConfig: (state, action) => {
+      return { ...state, ...action.payload };
+    }
+  }
+});
+var footerSlice = slice2;
+var footerActions = { setFooterVisible, setFooterConfig, ...restActions };
+var footerSlice_default = slice2.reducer;
+
+// src/slices/menuSlice.ts
+var import_state4 = require("@hai3/state");
+var SLICE_KEY3 = "layout/menu";
+var initialState3 = {
+  collapsed: false,
+  items: [],
+  visible: true
+};
+var { slice: slice3, toggleMenu, setMenuCollapsed, setMenuItems, setMenuVisible, setMenuConfig } = (0, import_state4.createSlice)({
+  name: SLICE_KEY3,
+  initialState: initialState3,
+  reducers: {
+    toggleMenu: (state) => {
+      state.collapsed = !state.collapsed;
+    },
+    setMenuCollapsed: (state, action) => {
+      state.collapsed = action.payload;
+    },
+    setMenuItems: (state, action) => {
+      state.items = action.payload;
+    },
+    setMenuVisible: (state, action) => {
+      state.visible = action.payload;
+    },
+    setMenuConfig: (state, action) => {
+      return { ...state, ...action.payload };
+    }
+  }
+});
+var menuSlice = slice3;
+var menuActions = { toggleMenu, setMenuCollapsed, setMenuItems, setMenuVisible, setMenuConfig };
+var menuSlice_default = slice3.reducer;
+
+// src/slices/sidebarSlice.ts
+var import_state5 = require("@hai3/state");
+var SLICE_KEY4 = "layout/sidebar";
+var initialState4 = {
+  collapsed: false,
+  position: "left",
+  title: null,
+  content: null,
+  visible: false,
+  width: 256
+};
+var {
+  slice: slice4,
+  toggleSidebar,
+  setSidebarCollapsed,
+  setSidebarPosition,
+  setSidebarTitle,
+  setSidebarContent,
+  setSidebarVisible,
+  setSidebarWidth,
+  setSidebarConfig
+} = (0, import_state5.createSlice)({
+  name: SLICE_KEY4,
+  initialState: initialState4,
+  reducers: {
+    toggleSidebar: (state) => {
+      state.collapsed = !state.collapsed;
+    },
+    setSidebarCollapsed: (state, action) => {
+      state.collapsed = action.payload;
+    },
+    setSidebarPosition: (state, action) => {
+      state.position = action.payload;
+    },
+    setSidebarTitle: (state, action) => {
+      state.title = action.payload;
+    },
+    setSidebarContent: (state, action) => {
+      state.content = action.payload;
+    },
+    setSidebarVisible: (state, action) => {
+      state.visible = action.payload;
+    },
+    setSidebarWidth: (state, action) => {
+      state.width = action.payload;
+    },
+    setSidebarConfig: (state, action) => {
+      return { ...state, ...action.payload };
+    }
+  }
+});
+var sidebarSlice = slice4;
+var sidebarActions = {
+  toggleSidebar,
+  setSidebarCollapsed,
+  setSidebarPosition,
+  setSidebarTitle,
+  setSidebarContent,
+  setSidebarVisible,
+  setSidebarWidth,
+  setSidebarConfig
+};
+var sidebarSlice_default = slice4.reducer;
+
+// src/slices/screenSlice.ts
+var import_state6 = require("@hai3/state");
+var SLICE_KEY5 = "layout/screen";
+var initialState5 = {
+  activeScreen: null,
+  loading: false
+};
+var { slice: slice5, setActiveScreen, setScreenLoading, navigateTo, clearActiveScreen } = (0, import_state6.createSlice)({
+  name: SLICE_KEY5,
+  initialState: initialState5,
+  reducers: {
+    setActiveScreen: (state, action) => {
+      state.activeScreen = action.payload;
+    },
+    setScreenLoading: (state, action) => {
+      state.loading = action.payload;
+    },
+    navigateTo: (state, action) => {
+      state.activeScreen = action.payload;
+    },
+    clearActiveScreen: (state) => {
+      state.activeScreen = null;
+    }
+  }
+});
+var screenSlice = slice5;
+var screenActions = { setActiveScreen, setScreenLoading, navigateTo, clearActiveScreen };
+var screenSlice_default = slice5.reducer;
+
+// src/slices/popupSlice.ts
+var import_state7 = require("@hai3/state");
+var SLICE_KEY6 = "layout/popup";
+var initialState6 = {
+  stack: []
+};
+var { slice: slice6, openPopup, closePopup, closeTopPopup, closeAllPopups } = (0, import_state7.createSlice)({
+  name: SLICE_KEY6,
+  initialState: initialState6,
+  reducers: {
+    openPopup: (state, action) => {
+      const zIndex = 1e3 + state.stack.length * 10;
+      state.stack.push({ ...action.payload, zIndex });
+    },
+    closePopup: (state, action) => {
+      state.stack = state.stack.filter((popup) => popup.id !== action.payload);
+    },
+    closeTopPopup: (state) => {
+      state.stack.pop();
+    },
+    closeAllPopups: (state) => {
+      state.stack = [];
+    }
+  }
+});
+var popupSlice = slice6;
+var popupActions = { openPopup, closePopup, closeTopPopup, closeAllPopups };
+var popupSlice_default = slice6.reducer;
+
+// src/slices/overlaySlice.ts
+var import_state8 = require("@hai3/state");
+var SLICE_KEY7 = "layout/overlay";
+var initialState7 = {
+  visible: false
+};
+var { slice: slice7, showOverlay, hideOverlay, setOverlayVisible } = (0, import_state8.createSlice)({
+  name: SLICE_KEY7,
+  initialState: initialState7,
+  reducers: {
+    showOverlay: (state) => {
+      state.visible = true;
+    },
+    hideOverlay: (state) => {
+      state.visible = false;
+    },
+    setOverlayVisible: (state, action) => {
+      state.visible = action.payload;
+    }
+  }
+});
+var overlaySlice = slice7;
+var overlayActions = { showOverlay, hideOverlay, setOverlayVisible };
+var overlaySlice_default = slice7.reducer;
+
+// src/slices/tenantSlice.ts
+var import_state9 = require("@hai3/state");
+var SLICE_KEY8 = "app/tenant";
+var initialState8 = {
+  tenant: null,
+  loading: false
+};
+var { slice: slice8, setTenant, setTenantLoading, clearTenant } = (0, import_state9.createSlice)({
+  name: SLICE_KEY8,
+  initialState: initialState8,
+  reducers: {
+    setTenant: (state, action) => {
+      state.tenant = action.payload;
+      state.loading = false;
+    },
+    setTenantLoading: (state, action) => {
+      state.loading = action.payload;
+    },
+    clearTenant: (state) => {
+      state.tenant = null;
+      state.loading = false;
+    }
+  }
+});
+var tenantSlice = slice8;
+var tenantActions = { setTenant, setTenantLoading, clearTenant };
+var tenantSlice_default = slice8.reducer;
+
+// src/slices/index.ts
+var LAYOUT_SLICE_NAME = "layout";
+var TENANT_SLICE_NAME = "app/tenant";
+var layoutDomainReducers = {
+  header: headerSlice_default,
+  footer: footerSlice_default,
+  menu: menuSlice_default,
+  sidebar: sidebarSlice_default,
+  screen: screenSlice_default,
+  popup: popupSlice_default,
+  overlay: overlaySlice_default
+};
+var layoutReducer = (0, import_toolkit.combineReducers)(layoutDomainReducers);
+
+// src/plugins/screensets.ts
+var screenSlice2 = screenSlice;
+var screenActions2 = screenActions;
+function screensets(config) {
+  const screensetRegistry3 = import_screensets.screensetRegistry;
+  return {
+    name: "screensets",
+    dependencies: [],
+    provides: {
+      registries: {
+        screensetRegistry: screensetRegistry3
+      },
+      slices: [screenSlice2],
+      actions: {
+        setActiveScreen: screenActions2.navigateTo,
+        setScreenLoading: screenActions2.setScreenLoading
+      }
+    },
+    onInit() {
+      if (config?.autoDiscover) {
+        console.log(
+          "[HAI3] Auto-discover is enabled. Screensets should be registered via screensetRegistry.register() in your app."
+        );
+      }
+    }
+  };
+}
+
+// src/plugins/themes.ts
+var import_state11 = require("@hai3/state");
+
+// src/compat.ts
+var import_state10 = require("@hai3/state");
+var import_api2 = require("@hai3/api");
+var import_screensets2 = require("@hai3/screensets");
+
+// src/registries/themeRegistry.ts
+function createThemeRegistry() {
+  const themes2 = /* @__PURE__ */ new Map();
+  const legacyThemes = /* @__PURE__ */ new Map();
+  let currentThemeId = null;
+  let customApplyFn = null;
+  const subscribers = /* @__PURE__ */ new Set();
+  let version = 0;
+  function notifySubscribers() {
+    version++;
+    subscribers.forEach((callback) => callback());
+  }
+  function applyCSSVariables(config) {
+    if (typeof document === "undefined") return;
+    const root = document.documentElement;
+    Object.entries(config.variables).forEach(([key, value]) => {
+      root.style.setProperty(key, value);
+    });
+  }
+  return {
+    /**
+     * Register a theme.
+     * Supports both new API (config only) and legacy API (id + theme).
+     */
+    register(configOrId, legacyTheme) {
+      if (typeof configOrId === "string") {
+        const id = configOrId;
+        if (!legacyTheme) {
+          console.warn(`register() called with ID "${id}" but no theme object. Skipping.`);
+          return;
+        }
+        if (themes2.has(id)) {
+          console.warn(`Theme "${id}" is already registered. Skipping.`);
+          return;
+        }
+        legacyThemes.set(id, legacyTheme);
+        let themeName = id;
+        if (legacyTheme && typeof legacyTheme === "object" && "name" in legacyTheme) {
+          const nameValue = legacyTheme.name;
+          if (typeof nameValue === "string") {
+            themeName = nameValue;
+          }
+        }
+        const config2 = {
+          id,
+          name: themeName,
+          variables: {}
+          // Legacy themes use custom apply function
+        };
+        themes2.set(id, config2);
+        return;
+      }
+      const config = configOrId;
+      if (themes2.has(config.id)) {
+        console.warn(`Theme "${config.id}" is already registered. Skipping.`);
+        return;
+      }
+      themes2.set(config.id, config);
+      if (config.default && currentThemeId === null) {
+        this.apply(config.id);
+      }
+    },
+    /**
+     * Set the apply function (legacy API).
+     */
+    setApplyFunction(applyFn) {
+      customApplyFn = applyFn;
+    },
+    /**
+     * Get theme by ID.
+     */
+    get(id) {
+      return themes2.get(id);
+    },
+    /**
+     * Get all themes.
+     */
+    getAll() {
+      return Array.from(themes2.values());
+    },
+    /**
+     * Apply a theme.
+     */
+    apply(id) {
+      const config = themes2.get(id);
+      if (!config) {
+        console.warn(`Theme "${id}" not found. Cannot apply.`);
+        return;
+      }
+      const legacyTheme = legacyThemes.get(id);
+      if (legacyTheme && customApplyFn) {
+        customApplyFn(legacyTheme, id);
+      } else if (config.variables && Object.keys(config.variables).length > 0) {
+        applyCSSVariables(config);
+      }
+      currentThemeId = id;
+      notifySubscribers();
+    },
+    /**
+     * Get current theme.
+     */
+    getCurrent() {
+      return currentThemeId ? themes2.get(currentThemeId) : void 0;
+    },
+    /**
+     * Subscribe to theme changes.
+     * Returns unsubscribe function.
+     */
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    },
+    /**
+     * Get current version number.
+     * Used by React for re-rendering.
+     */
+    getVersion() {
+      return version;
+    }
+  };
+}
+
+// src/registries/routeRegistry.ts
+function createRouteRegistry(screensetRegistry3) {
+  let routes = null;
+  function buildRoutes() {
+    if (routes !== null) {
+      return routes;
+    }
+    routes = [];
+    const screensets2 = screensetRegistry3.getAll();
+    screensets2.forEach((screenset) => {
+      screenset.menu.forEach((menuScreenItem) => {
+        const screenId = menuScreenItem.menuItem.screenId ?? menuScreenItem.menuItem.id;
+        if (screenId && menuScreenItem.screen) {
+          routes.push({
+            screensetId: screenset.id,
+            screenId,
+            loader: menuScreenItem.screen
+          });
+        }
+      });
+    });
+    return routes;
+  }
+  return {
+    /**
+     * Check if a screen exists by screenId only (globally unique).
+     */
+    hasScreenById(screenId) {
+      const allRoutes = buildRoutes();
+      return allRoutes.some((route) => route.screenId === screenId);
+    },
+    /**
+     * Check if a screen exists (legacy, requires both IDs).
+     */
+    hasScreen(screensetId, screenId) {
+      const allRoutes = buildRoutes();
+      return allRoutes.some(
+        (route) => route.screensetId === screensetId && route.screenId === screenId
+      );
+    },
+    /**
+     * Get screenset ID for a given screen ID (reverse lookup).
+     * Screen IDs are globally unique across all screensets.
+     */
+    getScreensetForScreen(screenId) {
+      const allRoutes = buildRoutes();
+      const route = allRoutes.find((r) => r.screenId === screenId);
+      return route?.screensetId;
+    },
+    /**
+     * Get screen loader by screenId only.
+     */
+    getScreenById(screenId) {
+      const allRoutes = buildRoutes();
+      const route = allRoutes.find((r) => r.screenId === screenId);
+      return route?.loader;
+    },
+    /**
+     * Get screen loader (legacy, requires both IDs).
+     */
+    getScreen(screensetId, screenId) {
+      const allRoutes = buildRoutes();
+      const route = allRoutes.find(
+        (r) => r.screensetId === screensetId && r.screenId === screenId
+      );
+      return route?.loader;
+    },
+    /**
+     * Get all routes.
+     */
+    getAll() {
+      const allRoutes = buildRoutes();
+      return allRoutes.map(({ screensetId, screenId }) => ({
+        screensetId,
+        screenId
+      }));
+    }
+  };
+}
+
+// src/compat.ts
+var import_screensets3 = require("@hai3/screensets");
+var screenActions3 = screenActions;
+var ACCOUNTS_DOMAIN = "accounts";
+var themeRegistry = createThemeRegistry();
+var routeRegistry = createRouteRegistry(import_screensets2.screensetRegistry);
+var navigateToScreen = (screenId) => {
+  (0, import_state10.getStore)().dispatch(screenActions3.setActiveScreen(screenId));
+};
+var fetchCurrentUser = () => (_dispatch) => {
+  try {
+    const accountsService = import_api2.apiRegistry.getService(ACCOUNTS_DOMAIN);
+    const service = accountsService;
+    service.getCurrentUser?.();
+  } catch {
+    console.warn("fetchCurrentUser: accounts service not registered");
+  }
+};
+
+// src/plugins/themes.ts
+function changeTheme(payload) {
+  import_state11.eventBus.emit("theme/changed", payload);
+}
+function themes() {
+  const themeRegistry2 = themeRegistry;
+  return {
+    name: "themes",
+    dependencies: [],
+    provides: {
+      registries: {
+        themeRegistry: themeRegistry2
+      },
+      actions: {
+        changeTheme
+      }
+    },
+    onInit(_app) {
+      import_state11.eventBus.on("theme/changed", (payload) => {
+        themeRegistry2.apply(payload.themeId);
+      });
+      const themes2 = themeRegistry2.getAll();
+      if (themes2.length > 0) {
+        themeRegistry2.apply(themes2[0].id);
+      }
+    }
+  };
+}
+
+// src/plugins/layout.ts
+var import_state12 = require("@hai3/state");
+var headerSlice2 = headerSlice;
+var footerSlice2 = footerSlice;
+var menuSlice2 = menuSlice;
+var sidebarSlice2 = sidebarSlice;
+var popupSlice2 = popupSlice;
+var overlaySlice2 = overlaySlice;
+var headerActions2 = headerActions;
+var footerActions2 = footerActions;
+var menuActions2 = menuActions;
+var sidebarActions2 = sidebarActions;
+var popupActions2 = popupActions;
+var overlayActions2 = overlayActions;
+function showPopup(payload) {
+  import_state12.eventBus.emit("layout/popup/requested", payload);
+}
+function hidePopup() {
+  import_state12.eventBus.emit("layout/popup/hidden");
+}
+function showOverlay2(payload) {
+  import_state12.eventBus.emit("layout/overlay/requested", payload);
+}
+function hideOverlay2() {
+  import_state12.eventBus.emit("layout/overlay/hidden");
+}
+function toggleMenuCollapsed(payload) {
+  import_state12.eventBus.emit("layout/menu/collapsed", payload);
+}
+function toggleSidebarCollapsed(payload) {
+  import_state12.eventBus.emit("layout/sidebar/collapsed", payload);
+}
+function layout() {
+  return {
+    name: "layout",
+    dependencies: ["screensets"],
+    provides: {
+      slices: [
+        headerSlice2,
+        footerSlice2,
+        menuSlice2,
+        sidebarSlice2,
+        popupSlice2,
+        overlaySlice2
+      ],
+      actions: {
+        showPopup,
+        hidePopup,
+        showOverlay: showOverlay2,
+        hideOverlay: hideOverlay2,
+        toggleMenuCollapsed,
+        toggleSidebarCollapsed,
+        // Direct slice actions for backward compatibility
+        setHeaderVisible: headerActions2.setVisible,
+        setFooterVisible: footerActions2.setVisible,
+        setMenuCollapsed: menuActions2.setCollapsed,
+        setSidebarCollapsed: sidebarActions2.setCollapsed
+      }
+    },
+    onInit(app) {
+      const dispatch = app.store.dispatch;
+      import_state12.eventBus.on("layout/popup/requested", (payload) => {
+        dispatch(popupActions2.open({
+          id: payload.id,
+          title: payload.title,
+          content: payload.content,
+          size: payload.size
+        }));
+      });
+      import_state12.eventBus.on("layout/popup/hidden", () => {
+        dispatch(popupActions2.close());
+      });
+      import_state12.eventBus.on("layout/overlay/requested", (payload) => {
+        dispatch(overlayActions2.show({ id: payload.id }));
+      });
+      import_state12.eventBus.on("layout/overlay/hidden", () => {
+        dispatch(overlayActions2.hide());
+      });
+      import_state12.eventBus.on("layout/menu/collapsed", (payload) => {
+        dispatch(menuActions2.setCollapsed(payload.collapsed));
+      });
+      import_state12.eventBus.on("layout/sidebar/collapsed", (payload) => {
+        dispatch(sidebarActions2.setCollapsed(payload.collapsed));
+      });
+    }
+  };
+}
+
+// src/plugins/navigation.ts
+var import_state13 = require("@hai3/state");
+var import_i18n = require("@hai3/i18n");
+var screenActions4 = screenActions;
+var menuActions3 = menuActions;
+function buildMenuItems(screenset) {
+  return screenset.menu.map((item) => ({
+    id: item.menuItem.screenId ?? item.menuItem.id,
+    label: item.menuItem.label,
+    icon: item.menuItem.icon
+  }));
+}
+function navigateToScreen2(payload) {
+  import_state13.eventBus.emit("navigation/screen/navigated", payload);
+}
+function navigateToScreenset(payload) {
+  import_state13.eventBus.emit("navigation/screenset/navigated", payload);
+}
+function navigation() {
+  return {
+    name: "navigation",
+    dependencies: ["screensets"],
+    provides: {
+      actions: {
+        navigateToScreen: navigateToScreen2,
+        navigateToScreenset
+      }
+    },
+    onInit(app) {
+      const dispatch = app.store.dispatch;
+      let currentScreensetId = null;
+      async function loadScreensetTranslations(screensetId, language) {
+        await import_i18n.i18nRegistry.loadScreensetTranslations(screensetId, language);
+      }
+      function updateMenuForScreenset(screensetId) {
+        if (screensetId === currentScreensetId) return;
+        const screenset = app.screensetRegistry.get(screensetId);
+        if (!screenset) return;
+        currentScreensetId = screensetId;
+        loadScreensetTranslations(screensetId).catch((err) => {
+          console.warn(`[HAI3] Failed to load translations for screenset ${screensetId}:`, err);
+        });
+        const menuItems = buildMenuItems(screenset);
+        dispatch(menuActions3.setMenuItems(menuItems));
+      }
+      import_state13.eventBus.on("navigation/screen/navigated", (payload) => {
+        if (app.routeRegistry && !app.routeRegistry.hasScreen(payload.screensetId, payload.screenId)) {
+          console.warn(
+            `Screen "${payload.screenId}" in screenset "${payload.screensetId}" not found.`
+          );
+          return;
+        }
+        updateMenuForScreenset(payload.screensetId);
+        dispatch(screenActions4.navigateTo(payload.screenId));
+        if (typeof window !== "undefined") {
+          const url = `/${payload.screenId}`;
+          window.history.pushState(null, "", url);
+        }
+      });
+      import_state13.eventBus.on("navigation/screenset/navigated", (payload) => {
+        const screenset = app.screensetRegistry.get(payload.screensetId);
+        if (!screenset) {
+          console.warn(`Screenset "${payload.screensetId}" not found.`);
+          return;
+        }
+        navigateToScreen2({
+          screensetId: payload.screensetId,
+          screenId: screenset.defaultScreen
+        });
+      });
+      let lastLoadedLanguage = null;
+      import_i18n.i18nRegistry.subscribe(() => {
+        const currentLanguage = import_i18n.i18nRegistry.getLanguage();
+        if (!currentLanguage || currentLanguage === lastLoadedLanguage) return;
+        if (!currentScreensetId) return;
+        const screenset = app.screensetRegistry.get(currentScreensetId);
+        if (!screenset) return;
+        lastLoadedLanguage = currentLanguage;
+        loadScreensetTranslations(currentScreensetId, currentLanguage).then(() => {
+          const menuItems = buildMenuItems(screenset);
+          dispatch(menuActions3.setMenuItems(menuItems));
+        }).catch((err) => {
+          console.warn(
+            `[HAI3] Failed to reload translations for screenset ${currentScreensetId}:`,
+            err
+          );
+        });
+      });
+      if (typeof window !== "undefined") {
+        window.addEventListener("popstate", () => {
+          const path2 = window.location.pathname;
+          const parts2 = path2.split("/").filter(Boolean);
+          if (parts2.length >= 1) {
+            const screenId = parts2[0];
+            const screensetId = app.routeRegistry?.getScreensetForScreen(screenId);
+            if (screensetId) {
+              updateMenuForScreenset(screensetId);
+              dispatch(screenActions4.navigateTo(screenId));
+            }
+          }
+        });
+        const path = window.location.pathname;
+        const parts = path.split("/").filter(Boolean);
+        const autoNavigate = app.config.autoNavigate !== false;
+        if (parts.length >= 1) {
+          const screenId = parts[0];
+          const screensetId = app.routeRegistry?.getScreensetForScreen(screenId);
+          if (screensetId) {
+            navigateToScreen2({ screensetId, screenId });
+          } else if (autoNavigate) {
+            const screensets2 = app.screensetRegistry.getAll();
+            if (screensets2.length > 0) {
+              navigateToScreenset({ screensetId: screensets2[0].id });
+            }
+          }
+        } else if (autoNavigate) {
+          const screensets2 = app.screensetRegistry.getAll();
+          if (screensets2.length > 0) {
+            navigateToScreenset({ screensetId: screensets2[0].id });
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/plugins/routing.ts
+function routing() {
+  return {
+    name: "routing",
+    dependencies: ["screensets"],
+    onRegister(_app) {
+    },
+    onInit(app) {
+      const routeRegistry2 = createRouteRegistry(app.screensetRegistry);
+      app.routeRegistry = routeRegistry2;
+    }
+  };
+}
+
+// src/plugins/i18n.ts
+var import_state14 = require("@hai3/state");
+var import_i18n2 = require("@hai3/i18n");
+function setLanguage(payload) {
+  import_state14.eventBus.emit("i18n/language/changed", payload);
+}
+function i18n() {
+  const i18nRegistry3 = import_i18n2.i18nRegistry;
+  return {
+    name: "i18n",
+    dependencies: [],
+    provides: {
+      registries: {
+        i18nRegistry: i18nRegistry3
+      },
+      actions: {
+        setLanguage
+      }
+    },
+    onInit(_app) {
+      import_state14.eventBus.on("i18n/language/changed", async (payload) => {
+        await i18nRegistry3.setLanguage(payload.language);
+      });
+      i18nRegistry3.setLanguage(import_i18n2.Language.English).catch((err) => {
+        console.warn("[HAI3] Failed to load initial translations:", err);
+      });
+    }
+  };
+}
+
+// src/plugins/effects.ts
+function effects() {
+  return {
+    name: "effects",
+    dependencies: [],
+    onInit(app) {
+      if (app.config.devMode) {
+        console.log("[HAI3] Effects plugin initialized");
+      }
+    }
+  };
+}
+
+// src/presets/index.ts
+function full() {
+  return [
+    effects(),
+    screensets({ autoDiscover: true }),
+    themes(),
+    layout(),
+    routing(),
+    navigation(),
+    i18n()
+  ];
+}
+function minimal() {
+  return [
+    screensets({ autoDiscover: true }),
+    themes()
+  ];
+}
+function headless() {
+  return [
+    screensets()
+  ];
+}
+var presets = {
+  full,
+  minimal,
+  headless
+};
+
+// src/createHAI3App.ts
+function createHAI3App(config) {
+  return createHAI3(config).useAll(full()).build();
+}
+
+// src/registries/index.ts
+var import_screensets6 = require("@hai3/screensets");
+
+// src/index.ts
+var import_state16 = require("@hai3/state");
+var import_screensets7 = require("@hai3/screensets");
+
+// src/effects/tenantEffects.ts
+var import_state15 = require("@hai3/state");
+var TenantEvents = {
+  Changed: "app/tenant/changed",
+  Cleared: "app/tenant/cleared"
+};
+function initTenantEffects() {
+  const store = (0, import_state15.getStore)();
+  const subChanged = import_state15.eventBus.on(TenantEvents.Changed, (payload) => {
+    store.dispatch(setTenant(payload.tenant));
+  });
+  const subCleared = import_state15.eventBus.on(TenantEvents.Cleared, () => {
+    store.dispatch(clearTenant());
+  });
+  return () => {
+    subChanged.unsubscribe();
+    subCleared.unsubscribe();
+  };
+}
+function changeTenant(tenant) {
+  import_state15.eventBus.emit(TenantEvents.Changed, { tenant });
+}
+function clearTenantAction() {
+  import_state15.eventBus.emit(TenantEvents.Cleared, {});
+}
+function setTenantLoadingState(loading) {
+  (0, import_state15.getStore)().dispatch(setTenantLoading(loading));
+}
+
+// src/index.ts
+var import_api3 = require("@hai3/api");
+var import_i18n5 = require("@hai3/i18n");
+var import_i18n6 = require("@hai3/i18n");
+
+// src/migration.ts
+var STATE_PATH_MAPPING = {
+  // App state (moved to app slice)
+  "uicore.app.user": "app.user",
+  "uicore.app.tenant": "app.tenant",
+  "uicore.app.language": "app.language",
+  "uicore.app.translationsReady": "app.translationsReady",
+  "uicore.app.loading": "app.loading",
+  "uicore.app.error": "app.error",
+  "uicore.app.useMockApi": "app.useMockApi",
+  // Layout state (split into domains)
+  "uicore.layout.theme": "app.theme",
+  "uicore.layout.currentScreenset": "app.currentScreenset",
+  "uicore.layout.selectedScreen": "layout.screen.activeScreen",
+  // Domain states (moved to layout.*)
+  "uicore.header": "layout.header",
+  "uicore.footer": "layout.footer",
+  "uicore.menu": "layout.menu",
+  "uicore.sidebar": "layout.sidebar",
+  "uicore.screen": "layout.screen",
+  "uicore.popup": "layout.popup",
+  "uicore.overlay": "layout.overlay"
+};
+var deprecationWarningsEnabled = true;
+function setDeprecationWarnings(enabled) {
+  deprecationWarningsEnabled = enabled;
+}
+function isDeprecationWarningsEnabled() {
+  return deprecationWarningsEnabled;
+}
+function createLegacySelector(legacyPath, newSelector, migrationHint) {
+  let hasWarned = false;
+  return (state) => {
+    if (deprecationWarningsEnabled && !hasWarned && process.env.NODE_ENV === "development") {
+      hasWarned = true;
+      const newPath = STATE_PATH_MAPPING[legacyPath] ?? "unknown";
+      const hint = migrationHint ?? `Use the new state path: ${newPath}`;
+      console.warn(
+        `[HAI3 Migration] Deprecated selector accessing "${legacyPath}". ${hint}`
+      );
+    }
+    return newSelector(state);
+  };
+}
+function getLayoutDomainState(state, domain) {
+  return state.layout[domain];
+}
+function hasLegacyUicoreState(state) {
+  return typeof state === "object" && state !== null && "uicore" in state && typeof state.uicore === "object";
+}
+function hasNewLayoutState(state) {
+  return typeof state === "object" && state !== null && "layout" in state && typeof state.layout === "object";
+}
+var legacySelectors = {};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACCOUNTS_DOMAIN,
+  BaseApiService,
+  I18nRegistry,
+  I18nRegistryImpl,
+  LAYOUT_SLICE_NAME,
+  Language,
+  LanguageDisplayMode,
+  LayoutDomain,
+  MockPlugin,
+  RestProtocol,
+  STATE_PATH_MAPPING,
+  SUPPORTED_LANGUAGES,
+  ScreensetCategory,
+  SseProtocol,
+  TENANT_SLICE_NAME,
+  TenantEvents,
+  TextDirection,
+  apiRegistry,
+  changeTenant,
+  clearActiveScreen,
+  clearTenant,
+  clearTenantAction,
+  clearUser,
+  closeAllPopups,
+  closePopup,
+  closeTopPopup,
+  createHAI3,
+  createHAI3App,
+  createI18nRegistry,
+  createLegacySelector,
+  createRouteRegistry,
+  createScreensetRegistry,
+  createSlice,
+  createStore,
+  createThemeRegistry,
+  effects,
+  eventBus,
+  fetchCurrentUser,
+  footerActions,
+  footerSlice,
+  full,
+  getLanguageMetadata,
+  getLayoutDomainState,
+  getStore,
+  hasLegacyUicoreState,
+  hasNewLayoutState,
+  hasSlice,
+  headerActions,
+  headerSlice,
+  headless,
+  hideOverlay,
+  i18n,
+  i18nRegistry,
+  initTenantEffects,
+  isDeprecationWarningsEnabled,
+  layout,
+  layoutDomainReducers,
+  layoutReducer,
+  legacySelectors,
+  menuActions,
+  menuSlice,
+  minimal,
+  navigateTo,
+  navigateToScreen,
+  navigation,
+  openPopup,
+  overlayActions,
+  overlaySlice,
+  popupActions,
+  popupSlice,
+  presets,
+  registerSlice,
+  routeRegistry,
+  routing,
+  screenActions,
+  screenSlice,
+  screensetRegistry,
+  screensets,
+  setActiveScreen,
+  setDeprecationWarnings,
+  setFooterConfig,
+  setFooterVisible,
+  setHeaderLoading,
+  setMenuCollapsed,
+  setMenuConfig,
+  setMenuItems,
+  setMenuVisible,
+  setOverlayVisible,
+  setScreenLoading,
+  setSidebarCollapsed,
+  setSidebarConfig,
+  setSidebarContent,
+  setSidebarPosition,
+  setSidebarTitle,
+  setSidebarVisible,
+  setSidebarWidth,
+  setTenant,
+  setTenantLoading,
+  setTenantLoadingState,
+  setUser,
+  showOverlay,
+  sidebarActions,
+  sidebarSlice,
+  tenantActions,
+  tenantReducer,
+  tenantSlice,
+  themeRegistry,
+  themes,
+  toggleMenu,
+  toggleSidebar
+});
+//# sourceMappingURL=index.cjs.map