@postnord/pn-marketweb-components 4.2.4 → 4.3.0

package/types/components/layout-components/pn-marketweb-header/components/shared/pn-marketweb-header-shared.d.ts

@@ -0,0 +1,48 @@
+import type { SiteHeaderI18N } from '../../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+import type { HeaderMenuMode, HeaderViewModel } from '../../types/pn-marketweb-header.types';
+import { HeaderAppearance } from '../../utils/header-theme';
+export interface HeaderLogoRenderProps {
+    homePageLink?: string;
+    homeLabel: string;
+}
+export interface HeaderMenuToggleRenderProps {
+    vm: HeaderViewModel;
+    activeMenuMode: HeaderMenuMode;
+    navigateOnMenuToggle: boolean;
+    onMenuToggleChange: (e: CustomEvent<HeaderMenuMode>) => void;
+}
+export interface HeaderLoginRenderProps {
+    vm: HeaderViewModel;
+    hideLogin: boolean;
+    userToken: string;
+    userFullname: string;
+    userLoggedin: boolean;
+    endpoint?: string;
+    environment?: string;
+    i18n: SiteHeaderI18N;
+    showProfileSelection: boolean;
+    showUnifiedLogin: boolean;
+    checkUserLoggedInStateInterval: number;
+    useMarketwebLogin: boolean;
+    appearance: HeaderAppearance;
+}
+export interface HeaderLanguageSelectorRenderProps {
+    vm: HeaderViewModel;
+    hideLanguageSelector: boolean;
+    language?: string;
+    spaMode: boolean;
+    appearance: HeaderAppearance;
+}
+export interface HeaderSiteSelectorRenderProps {
+    vm: HeaderViewModel;
+    hideSiteSelector: boolean;
+    language?: string;
+    buttonText?: string;
+    appearance: HeaderAppearance;
+    adjustSiteSelectorUrl: (href: string) => string;
+}
+export declare function renderHeaderMenuSwitcher(props: HeaderMenuToggleRenderProps): any;
+export declare function renderHeaderLogo(props: HeaderLogoRenderProps): any;
+export declare function renderHeaderLogin(props: HeaderLoginRenderProps): any;
+export declare function renderHeaderLanguageSelector(props: HeaderLanguageSelectorRenderProps): any;
+export declare function renderHeaderSiteSelector(props: HeaderSiteSelectorRenderProps): any;

package/types/components/layout-components/pn-marketweb-header/mapper/pn-marketweb-header.mapper.d.ts

@@ -0,0 +1,34 @@
+import { HeaderApiPayload, HeaderMapperOptions, HeaderViewModel } from '../types/pn-marketweb-header.types';
+/**
+ * Maps backend header data into the internal renderable view model.
+ *
+ * This mapper is the normalization boundary between the backend header payload
+ * and the UI-facing header view model.
+ *
+ * Top-level menu interpretation:
+ * - all items except the last = switchable root menus
+ * - last item = shared/common root
+ *
+ * These semantics are inferred by position, not by stable backend identifiers.
+ *
+ * Responsibilities
+ * ----------------
+ * - normalize top-level backend payload sections
+ * - optionally adjust relative URLs against the site domain
+ * - detect whether the backend menu supports menu switching
+ * - preserve the raw normalized menu structure for the wrapper component
+ * - prepare a flat `menuItems` list for simpler rendering paths
+ *
+ * Important
+ * ---------
+ * - The switchable root items themselves are not intended to be rendered as
+ *   visible main navigation entries
+ * - Visible navigation is derived from:
+ *   - active root children
+ *   - plus shared/common root children
+ * - If only a shared/common root exists, its children are rendered flat
+ * - The wrapper component may choose either:
+ *   - `menuItems` for flat rendering
+ *   - or `rawMenuItems` + menu helpers for grouped rendering
+ */
+export declare function mapHeaderDataToViewModel(data: HeaderApiPayload, options: HeaderMapperOptions): HeaderViewModel;

package/types/components/layout-components/pn-marketweb-header/pn-marketweb-header.d.ts

@@ -0,0 +1,121 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import type { EnvironmentName, MarketName } from '../../../services/pn-refined-marketweb-context/pn-refined-marketweb-context.types';
+import { SiteHeaderI18N } from '../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+import type { HeaderMenuMode, HeaderViewModel } from './types/pn-marketweb-header.types';
+/**
+ * New marketweb header wrapper.
+ *
+ * Responsibilities:
+ * - resolve runtime context
+ * - fetch header data
+ * - map backend data into a renderable view model
+ * - render the layout using existing leaf/header components
+ * - owns the active menu mode when a switchable menu structure exists
+ */
+export declare class PnMarketwebHeader {
+    hostElement: HTMLElement;
+    initialActiveMenuMode: HeaderMenuMode;
+    /** Optional menu theme labels, e.g. ['Business', 'Private']. passed in as a sting via cms */
+    menuThemes?: string;
+    /** Market to use for the header. Falls back to refined context resolution when omitted. */
+    market: MarketName | null;
+    /** Language to use for the header. Falls back to refined context resolution when omitted. */
+    language: string | null;
+    /** Environment to use for the header. Falls back to refined context resolution when omitted. */
+    environment: EnvironmentName | null;
+    /** Explicit endpoint override. When omitted it is resolved from market + environment. */
+    endpoint: string | null;
+    /** Current site id (guid), forwarded into the search component. */
+    siteid: string | null;
+    /** Current page id forwarded to the header backend endpoint. */
+    pageId: string;
+    /** Access token passed from backend. */
+    userToken: string;
+    /** User full name from backend. */
+    userFullname: string;
+    /** User logged in state from backend. */
+    userLoggedin: boolean;
+    /** Hides the site selector when true. */
+    hideSiteSelector: boolean;
+    /** Hides the generated home menu item when true. */
+    hideHomeMenuItem: boolean;
+    /** Hides the language selector when true. */
+    hideLanguageSelector: boolean;
+    /** Hides search when true. */
+    hideSearch: boolean;
+    /** Hides login when true. */
+    hideLogin: boolean;
+    /** Enables profile selection presentation in the login component. */
+    showProfileSelection: boolean;
+    /** Enables unified login presentation in the login component. */
+    showUnifiedLogin: boolean;
+    /** Adjust relative URLs against the site domain when true. */
+    siteDomainInUrls: boolean;
+    /** Autocomplete endpoint forwarded into the search view model. */
+    autocompleteEndpoint: string;
+    /** Whether session forwarding should be attempted after login state changes. */
+    sessionForward: boolean;
+    /** Enables cached requests in FetchHelper when true. */
+    cache: boolean;
+    /** Optional override for translated search placeholder text. */
+    searchPlaceholder: string;
+    /** When true, language selector options should not navigate directly by URL. */
+    spaMode: boolean;
+    /** Interval forwarded to the login component for login state checks. */
+    checkUserLoggedInStateInterval: number;
+    /** Enables marketweb login mode in the login component. */
+    useMarketwebLogin: boolean;
+    /** When true, changing menu mode navigates to the selected root href. */
+    navigateOnMenuToggle: boolean;
+    /** The mapped UI state used for rendering the header. */
+    vm: HeaderViewModel | null;
+    /** Current translations for the active language. */
+    i18n: SiteHeaderI18N;
+    /** Simple loading state for the wrapper. */
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    /** Whether the main search should collapse to a compact version. */
+    minimizeSearch: boolean;
+    /** Internal login state used for special link handling. */
+    loggedIn: boolean;
+    /** Active menu mode when the backend structure supports menu switching. */
+    activeMenuMode: HeaderMenuMode;
+    /** Guard used to prevent watchers from reloading during initial setup. */
+    private isInitializing;
+    /** Cached raw backend payload so UI-only prop changes can remap without refetching. */
+    private rawHeaderData;
+    /** Main nav element reference used for overflow calculation. */
+    private mainNavEl?;
+    /** Emitted when the language changes. */
+    changeLanguage: EventEmitter<string>;
+    /** Emitted when the market changes. */
+    changeMarket: EventEmitter<MarketName>;
+    /** Shared helper for backend requests. */
+    private fetchHelper;
+    /** Service for context resolution and header-data fetching. */
+    private headerService;
+    private hasResolvedInitialMenuMode;
+    componentWillLoad(): Promise<void>;
+    onLanguageSelectorChange(e: CustomEvent<string>): void;
+    onLanguageChange(): Promise<void>;
+    onMarketChange(): Promise<void>;
+    onEnvironmentChange(): Promise<void>;
+    onEndpointChange(): Promise<void>;
+    onPageIdChange(): Promise<void>;
+    onPresentationInputChange(): void;
+    onLoginStateChange(e: CustomEvent<{
+        loggedIn?: boolean;
+        token?: string;
+    }>): void;
+    handleResize(): void;
+    private get menuThemeList();
+    private get logoUrl();
+    private loadHeader;
+    private remapViewModel;
+    private applyHeaderState;
+    private checkMenuOverflow;
+    private isUserLoggedIn;
+    private adjustSiteSelectorUrl;
+    private onMenuToggleChange;
+    private getVisibleMenuGroups;
+    render(): any;
+}

package/types/components/layout-components/pn-marketweb-header/pn-marketweb-header.stories.d.ts

@@ -0,0 +1,99 @@
+import type { Meta, StoryObj } from '@storybook/web-components';
+import type { HeaderApiEnvelope, HeaderMenuMode } from './types/pn-marketweb-header.types';
+/**
+ * Story args for pn-marketweb-header.
+ *
+ * This story:
+ * - renders the real pn-marketweb-header
+ * - can optionally intercept its backend fetch call
+ * - returns a mocked backend envelope when mocking is enabled
+ * - lets the actual header component render and control its own menu switcher
+ */
+interface StoryArgs {
+    market: string;
+    language: string;
+    initialActiveMenuMode: HeaderMenuMode;
+    menuThemes?: string;
+    environment: 'production' | 'preproduction' | 'integration' | 'localhost';
+    endpoint: string;
+    pageId: string;
+    siteid: string;
+    userToken: string;
+    userFullname: string;
+    userLoggedin: boolean;
+    hideSiteSelector: boolean;
+    hideHomeMenuItem: boolean;
+    hideLanguageSelector: boolean;
+    hideSearch: boolean;
+    hideLogin: boolean;
+    showProfileSelection: boolean;
+    showUnifiedLogin: boolean;
+    siteDomainInUrls: boolean;
+    autocompleteEndpoint: string;
+    sessionForward: boolean;
+    cache: boolean;
+    searchPlaceholder: string;
+    spaMode: boolean;
+    checkUserLoggedInStateInterval: number;
+    useMarketwebLogin: boolean;
+    navigateOnMenuToggle: boolean;
+    /**
+     * Mocked backend response envelope.
+     *
+     * This should match the real backend response shape.
+     */
+    mockedResponse: HeaderApiEnvelope;
+    /**
+     * When true, Storybook intercepts the header fetch and returns mockedResponse.
+     * When false, the real endpoint is used.
+     */
+    useMockedResponse: boolean;
+}
+declare const meta: Meta<StoryArgs>;
+export default meta;
+type Story = StoryObj<StoryArgs>;
+/**
+ * Baseline story:
+ * - 2 switchable roots
+ * - 1 shared root
+ */
+export declare const TwoModesWithShared: Story;
+/**
+ * Verifies that more than 2 switchable roots are supported.
+ */
+export declare const ThreeModesWithShared: Story;
+/**
+ * Only one mode root + shared.
+ * The header should not render the menu switcher.
+ */
+export declare const OneModeWithShared: Story;
+/**
+ * Shared-only structure.
+ * Useful for verifying fallback rendering when no switchable roots exist.
+ */
+export declare const SharedOnly: Story;
+/**
+ * Same baseline structure, but start on the second mode.
+ */
+export declare const StartOnSecondMode: Story;
+/**
+ * Same baseline structure, but allow real navigation hrefs on mode change.
+ * Mostly useful for checking rendered links rather than interacting in Storybook.
+ */
+export declare const NavigationEnabled: Story;
+/**
+ * Smaller layout story while still using mocked data.
+ */
+export declare const Minimal: Story;
+/**
+ * Menu items contain nested sub-menu items.
+ */
+export declare const NestedSubmenuItems: Story;
+/**
+ * Uses the real local CMS instead of Storybook fetch mocking.
+ */
+export declare const LocalCms: Story;
+/**
+ * Uses the real integration CMS instead of Storybook fetch mocking. //FIXME: getting cors-safe data at the moment
+ */
+export declare const IntegrationCms: Story;

package/types/components/layout-components/pn-marketweb-header/services/pn-marketweb-header.service.d.ts

@@ -0,0 +1,108 @@
+import { FetchHelper } from '../../../../globals/FetchHelper';
+import type { EnvironmentName, MarketName } from '../../../../services/pn-refined-marketweb-context/pn-refined-marketweb-context.types';
+import type { SiteHeaderI18N } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+import type { HeaderApiPayload, HeaderContext, HeaderMenuMode, HeaderViewModel } from '../types/pn-marketweb-header.types';
+/**
+ * Input used when resolving/fetching/building header state.
+ */
+export interface LoadHeaderStateInput {
+    market?: MarketName | null;
+    language?: string | null;
+    environment?: EnvironmentName | null;
+    endpoint?: string | null;
+    pageId?: string;
+    cache?: boolean;
+    hideHomeMenuItem: boolean;
+    siteDomainInUrls: boolean;
+    autocompleteEndpoint: string;
+    searchPlaceholder: string;
+}
+/**
+ * Result returned from service orchestration methods.
+ */
+export interface HeaderStateResult {
+    context: HeaderContext;
+    rawHeaderData: HeaderApiPayload | null;
+    vm: HeaderViewModel | null;
+    i18n: SiteHeaderI18N;
+    status: 'ready' | 'error';
+    /**
+     * The currently active menu mode used by the wrapper component.
+     *
+     * This is preserved by the service during remaps, but the effective initial
+     * value is resolved by the component layer.
+     */
+    activeMenuMode: HeaderMenuMode;
+}
+/**
+ * Service responsible for:
+ * - resolving the effective header context
+ * - building the fetch URL for the header endpoint
+ * - loading header data from the backend
+ * - mapping backend data into a renderable header state
+ *
+ * This service uses the refined context service as the source of truth
+ * for market/language/environment resolution.
+ */
+export declare class PnMarketwebHeaderService {
+    private fetchHelper;
+    private href;
+    private doc;
+    /**
+     * Fixed backend path for loading header data.
+     * This is appended to the resolved endpoint domain.
+     */
+    private endpointPath;
+    constructor(fetchHelper: FetchHelper, href?: string, doc?: Document);
+    /**
+     * Resolves the effective header context.
+     *
+     * What it does:
+     * - uses the RefinedMarketWebContextService to resolve context from the current URL/document
+     * - lets explicit input values override resolved values when provided
+     * - resolves endpoint from environment + market when endpoint is not explicitly passed in
+     * - keeps pageId as part of the final header request context
+     */
+    private resolveContext;
+    /**
+     * Builds the final request URL used to fetch header JSON.
+     *
+     * What it does:
+     * - removes a trailing slash from the endpoint base if needed
+     * - appends the fixed header endpoint path
+     * - adds query parameters for market, language and current page
+     */
+    private buildFetchUrl;
+    /**
+     * Fetches header data from the backend.
+     *
+     * Returns null when required context is missing.
+     */
+    private fetchHeaderData;
+    /**
+     * Builds i18n for the current language + presentation overrides.
+     */
+    private resolveI18n;
+    /**
+     * Maps raw header data into the current UI view model.
+     */
+    private mapViewModel;
+    /**
+     * Resolves context, fetches backend data and builds the final header state.
+     */
+    loadHeaderState(input: LoadHeaderStateInput): Promise<HeaderStateResult>;
+    /**
+     * Rebuilds the UI state from already-fetched raw backend data.
+     * Use this when presentation-only inputs change and a refetch is not needed.
+     */
+    remapHeaderState(input: {
+        context: HeaderContext;
+        rawHeaderData: HeaderApiPayload | null;
+        language?: string | null;
+        hideHomeMenuItem: boolean;
+        siteDomainInUrls: boolean;
+        autocompleteEndpoint: string;
+        searchPlaceholder: string;
+        currentActiveMenuMode: HeaderMenuMode;
+    }): HeaderStateResult;
+}

package/types/components/layout-components/pn-marketweb-header/types/pn-marketweb-header.types.d.ts

@@ -0,0 +1,103 @@
+import { EnvironmentName, MarketName } from '../../../../services/pn-refined-marketweb-context/pn-refined-marketweb-context.types';
+import { LanguageSelector, LanguageSelectorItem, LoginDialog, MenuItem, MenuSiteDefinition, SiteHeaderI18N, SiteHeaderSearch, SiteSelector } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+export type HeaderMenuMode = number;
+export interface HeaderMenuModeOption {
+    index: number;
+    label: string;
+    href?: string;
+    root: MenuItem;
+}
+export interface HeaderMenuStructure {
+    hasMenuSwitching: boolean;
+    modeRoots: MenuItem[];
+    menuModeOptions: HeaderMenuModeOption[];
+    sharedRoot: MenuItem | null;
+    sharedItems: MenuItem[];
+}
+export interface HeaderMenuGroups {
+    primaryItems: MenuItem[];
+    sharedItems: MenuItem[];
+}
+/**
+ * Resolved runtime context used when loading header data.
+ * These values may come from explicit props, URL parsing, or environment resolution.
+ */
+export interface HeaderContext {
+    market: MarketName;
+    language: string;
+    environment: EnvironmentName;
+    endpoint: string;
+    pageId?: string;
+}
+export interface HeaderApiPayload {
+    sitedefinition: MenuSiteDefinition;
+    search: SiteHeaderSearch;
+    languageSelectorViewModel: LanguageSelector | null;
+    siteSelectorViewModel: SiteSelector | null;
+    loginViewModel: LoginDialog | null;
+    mainMenu: {
+        menuItems: MenuItem[];
+    };
+}
+/**
+ * The raw API response shape returned by /api/navigation/header.
+ * This stays close to the backend structure.
+ */
+export interface HeaderApiEnvelope {
+    value: HeaderApiPayload;
+    formatters?: unknown[];
+    contentTypes?: unknown[];
+    declaredType?: unknown;
+    statusCode?: number;
+}
+export interface HeaderViewModel {
+    siteDefinition: MenuSiteDefinition | null;
+    menuItems: MenuItem[];
+    search: SiteHeaderSearch | null;
+    siteSelector: SiteSelector | null;
+    languageSelector: LanguageSelector | null;
+    languageOptions: LanguageSelectorItem[];
+    loginDialog: LoginDialog | null;
+    homePageLink: string;
+    /**
+     * Whether the fetched structure supports switching between multiple top-level menu roots.
+     *
+     * When true:
+     * - all top-level menu items except the last are treated as switchable roots
+     * - the last top-level item is treated as the shared/common root
+     */
+    hasMenuSwitching: boolean;
+    /**
+     * Visible labels for the toggle component.
+     */
+    menuModeOptions: HeaderMenuModeOption[];
+    /**
+     * Default active menu mode index.
+     *
+     * This index refers to `menuModeOptions` and the corresponding switchable
+     * top-level root menu.
+     */
+    defaultMenuMode: number;
+    /**
+     * Original normalized top-level menu structure from the backend.
+     *
+     * Semantics:
+     * - all items except the last are switchable root menus
+     * - the last item is the shared/common root
+     *
+     * This is preserved so the wrapper can rebuild visible menu items when the
+     * active menu mode changes.
+     */
+    rawMenuItems: MenuItem[];
+}
+/**
+ * Options used when mapping raw API data into a renderable view model.
+ * These mostly come from component props or derived i18n values.
+ */
+export interface HeaderMapperOptions {
+    language: string;
+    hideHomeMenuItem: boolean;
+    siteDomainInUrls: boolean;
+    autocompleteEndpoint?: string;
+    i18n: SiteHeaderI18N;
+}

package/types/components/layout-components/pn-marketweb-header/utils/header-i18n.d.ts

@@ -0,0 +1,16 @@
+import { SiteHeaderI18N } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+/**
+ * Safe fallback i18n object used before translations have been resolved,
+ * or if a language is missing from the translation table.
+ */
+export declare const defaultHeaderI18n: SiteHeaderI18N;
+/**
+ * Resolves the i18n object for the current language and applies overrides.
+ *
+ * What it does:
+ * - Looks up translation values for the selected language
+ * - Falls back to a safe default object if the language is missing
+ * - Allows the search placeholder to be overridden by a prop
+ * - Ensures "home" always has a non-empty fallback value
+ */
+export declare function resolveHeaderTranslations(language?: string, searchPlaceholder?: string): SiteHeaderI18N;

package/types/components/layout-components/pn-marketweb-header/utils/header-language.d.ts

@@ -0,0 +1,20 @@
+import { LanguageSelector, LanguageSelectorItem, MenuSiteDefinition } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+/**
+ * Builds the list of language options that should actually be shown.
+ *
+ * What it does:
+ * - Reads the backend-provided language selector model
+ * - Checks page <link rel="alternate" hreflang="..."> tags
+ * - If hreflang tags exist, only languages with matching tags are shown
+ * - If no hreflang tags exist, all backend-provided languages are shown
+ */
+export declare function getLanguageOptions(languageSelector: LanguageSelector | null): LanguageSelectorItem[];
+/**
+ * Resolves the URL for a given language option.
+ *
+ * What it does:
+ * - Returns null in SPA mode so language switching can be handled by events only
+ * - Uses an existing hreflang alternate URL if one exists in the document
+ * - Otherwise falls back to generating a language URL from the site definition
+ */
+export declare function getLanguageVersionUrl(item: LanguageSelectorItem, siteDefinition: MenuSiteDefinition | null, spaMode: boolean): string | null;

package/types/components/layout-components/pn-marketweb-header/utils/header-menu.d.ts

@@ -0,0 +1,16 @@
+import { MenuItem, PromotedMenuItem, SiteHeaderI18N } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+/**
+ * Adds a Home item at the beginning of the main menu when needed.
+ *
+ * What it does:
+ * - Returns the input untouched when hideHomeMenuItem is true
+ * - Avoids adding a duplicate Home item if one already exists first in the list
+ * - Otherwise prepends a synthetic Home item using the translated label
+ */
+export declare function prependHomeMenuItem(items: MenuItem[], i18n: SiteHeaderI18N, homeUrl: string, hideHomeMenuItem: boolean): MenuItem[];
+/**
+ * Creates a stable-ish tracking id for promoted menu items.
+ *
+ * This mirrors the old wrapper behavior and is used when rendering promoted links.
+ */
+export declare function promotedItemId(item: PromotedMenuItem): string;

package/types/components/layout-components/pn-marketweb-header/utils/header-theme.d.ts

@@ -0,0 +1,6 @@
+import type { HeaderMenuModeOption } from '../types/pn-marketweb-header.types';
+export type HeaderTheme = 'business' | 'private';
+export type HeaderAppearance = 'light' | 'dark';
+export declare function normalizeHeaderTheme(theme: HeaderTheme): HeaderTheme;
+export declare function getAppearanceForTheme(theme: HeaderTheme): HeaderAppearance;
+export declare function resolveHeaderMenuThemes(menuThemes: string | undefined, menuModeOptions: HeaderMenuModeOption[] | undefined): HeaderTheme[];

package/types/components/layout-components/pn-marketweb-header/utils/header-toggle-menu.d.ts

@@ -0,0 +1,49 @@
+import type { MenuItem } from '../../pn-marketweb-siteheader/pn-marketweb-siteheader-types';
+import type { HeaderMenuGroups, HeaderMenuMode, HeaderMenuStructure } from '../types/pn-marketweb-header.types';
+/**
+ * Header menu mode utilities.
+ *
+ * Purpose
+ * -------
+ * Interprets the backend top-level menu structure used for header menu
+ * switching.
+ *
+ * Expected top-level order:
+ * - all items except the last = switchable root menus
+ * - last item = shared/common root
+ *
+ * Responsibilities
+ * ----------------
+ * - extract a structured representation of the switchable menu roots
+ * - resolve the active root for a selected mode
+ * - return grouped or flat visible items for rendering
+ */
+export declare function extractToggleableMenuStructure(menuItems: MenuItem[]): HeaderMenuStructure;
+/**
+ * Returns the active root item for the selected mode.
+ *
+ * Falls back to the first available mode root when the requested mode
+ * is out of bounds.
+ */
+export declare function getToggleRootForMode(structure: HeaderMenuStructure, mode: HeaderMenuMode): MenuItem | null;
+/**
+ * Returns the active root item for the selected mode directly from raw menu items.
+ */
+export declare function getToggleRootForMenuItems(menuItems: MenuItem[], mode: HeaderMenuMode): MenuItem | null;
+/**
+ * Returns grouped visible items for rendering.
+ *
+ * - primaryItems = children of the active root
+ * - sharedItems = children of the shared/common root
+ */
+export declare function getMenuGroupsForMode(structure: HeaderMenuStructure, mode: HeaderMenuMode): HeaderMenuGroups;
+/**
+ * Returns grouped visible items directly from raw menu items.
+ */
+export declare function getVisibleMenuGroupsForMode(menuItems: MenuItem[], mode: HeaderMenuMode): HeaderMenuGroups;
+/**
+ * Builds a flat list of visible menu items for the selected mode.
+ *
+ * Useful for render paths that do not need grouped rendering.
+ */
+export declare function buildMenuItemsForMode(structure: HeaderMenuStructure, mode: HeaderMenuMode): MenuItem[];

package/types/components/layout-components/pn-marketweb-header/utils/header-toggle-menu.storage.d.ts

@@ -0,0 +1,25 @@
+import type { HeaderMenuMode } from '../types/pn-marketweb-header.types';
+/**
+ * Returns the previously selected menu mode from localStorage.
+ *
+ * Returns null if:
+ * - nothing is stored
+ * - value is invalid
+ * - storage is unavailable
+ */
+export declare function getStoredHeaderMenuMode(): HeaderMenuMode | null;
+/**
+ * Persists the selected menu mode in localStorage.
+ *
+ * Storage failures are intentionally ignored.
+ */
+export declare function storeHeaderMenuMode(mode: HeaderMenuMode): void;
+/**
+ * Resolves the effective initial menu mode.
+ *
+ * Priority:
+ * 1. Stored user preference
+ * 2. Server-provided initial mode
+ * 3. Fallback to first mode (index 0)
+ */
+export declare function resolveInitialHeaderMenuMode(hasMenuSwitching: boolean, initialActiveMenuMode?: HeaderMenuMode | null): HeaderMenuMode;