@agorapulse/ui-components 18.0.9 → 18.0.11

package/index.d.ts

@@ -22,6 +22,7 @@ export { SelectComponent } from '@agorapulse/ui-components/legacy/select';
 export { TextareaComponent } from '@agorapulse/ui-components/legacy/textarea';
 export { MediaDisplayOverlayDialogComponent } from '@agorapulse/ui-components/media-display-overlay';
 export { ModalComponent, ModalConfig } from '@agorapulse/ui-components/modal';
+export { NavSelectorComponent } from '@agorapulse/ui-components/nav-selector';
 export { DayDisabledPipe, NeoDatePickerLocale, NeoDatePickerMode, NeoDatePickerStartsOn, NeoDatepickerComponent, } from '@agorapulse/ui-components/neo-datepicker';
 export { NotificationComponent } from '@agorapulse/ui-components/notification';
 export { PaginatorButtonComponent, PaginatorComponent } from '@agorapulse/ui-components/paginator';

package/input-search/input-search.component.d.ts

@@ -23,7 +23,7 @@ export declare class InputSearchComponent implements ControlValueAccessor {
     focusInput(): void;
     writeValue(value: string | null): void;
     setDisabledState(isDisabled: boolean): void;
-    onClear(): void;
+    onClear($event: Event): void;
     onFocusHandle($event: FocusEvent): void;
     onBlurHandle($event: FocusEvent): void;
     onKeyup($event: KeyboardEvent): void;

package/nav-selector/directives/tree-node-accessibility.directive.d.ts

@@ -0,0 +1,9 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { InternalNavSelectorEntry } from '../nav-selector';
+import * as i0 from "@angular/core";
+export declare class TreeNodeAccessibilityDirective {
+    apTreeNodeAccessibility: import("@angular/core").InputSignal<InternalNavSelectorEntry>;
+    constructor(el: ElementRef, renderer: Renderer2);
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeAccessibilityDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeNodeAccessibilityDirective, "[apTreeNodeAccessibility]", never, { "apTreeNodeAccessibility": { "alias": "apTreeNodeAccessibility"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/nav-selector/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@agorapulse/ui-components/nav-selector" />
+export * from './public_api';

package/nav-selector/nav-selector-category/nav-selector-category.component.d.ts

@@ -0,0 +1,16 @@
+import { ElementRef } from '@angular/core';
+import { InternalNavSelectorCategory } from '../nav-selector';
+import { NavSelectorCategoryPresenter } from './nav-selector-category.presenter';
+import * as i0 from "@angular/core";
+export declare class NavSelectorCategoryComponent {
+    private el;
+    navSelectorCategoryPresenter: NavSelectorCategoryPresenter;
+    category: import("@angular/core").InputSignal<InternalNavSelectorCategory>;
+    foldSymbol: import("@angular/core").Signal<"chevron-down" | "chevron-up">;
+    foldedWithDelay: import("@angular/core").WritableSignal<boolean>;
+    animationState: import("@angular/core").Signal<"collapsed" | "expanded">;
+    constructor(el: ElementRef, navSelectorCategoryPresenter: NavSelectorCategoryPresenter);
+    maxHeight: import("@angular/core").WritableSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorCategoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorCategoryComponent, "ap-nav-selector-category", never, { "category": { "alias": "category"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/nav-selector/nav-selector-category/nav-selector-category.presenter.d.ts

@@ -0,0 +1,14 @@
+import { InternalNavSelectorCategory } from '../nav-selector';
+import { NavSelectorState } from '../nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorCategoryPresenter {
+    private navSelectorState;
+    expanded: import("@angular/core").Signal<boolean>;
+    expandedAfterDelay: import("@angular/core").Signal<boolean>;
+    constructor(navSelectorState: NavSelectorState);
+    toggleFolding(event: Event, category: InternalNavSelectorCategory): void;
+    fold(event: Event, category: InternalNavSelectorCategory): void;
+    unfold(event: Event, category: InternalNavSelectorCategory): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorCategoryPresenter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorCategoryPresenter>;
+}

package/nav-selector/nav-selector-group/nav-selector-group.component.d.ts

@@ -0,0 +1,29 @@
+import { ElementRef } from '@angular/core';
+import { InternalNavSelectorGroup } from '../nav-selector';
+import { NavSelectorGroupPresenter } from './nav-selector-group.presenter';
+import * as i0 from "@angular/core";
+export declare class NavSelectorGroupComponent {
+    private el;
+    navSelectorGroupPresenter: NavSelectorGroupPresenter;
+    group: import("@angular/core").InputSignal<InternalNavSelectorGroup>;
+    foldSymbol: import("@angular/core").Signal<"chevron-down" | "chevron-up">;
+    aliasEl: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    aliasBoundedClientRect: import("@angular/core").WritableSignal<{
+        offsetWidth: number;
+        offsetHeight: number;
+        scrollWidth: number;
+        scrollHeight: number;
+    }>;
+    tooltipContent: import("@angular/core").Signal<string>;
+    tooltipDisabled: import("@angular/core").Signal<boolean>;
+    foldedWithDelay: import("@angular/core").WritableSignal<boolean>;
+    animationState: import("@angular/core").Signal<"collapsed" | "expanded">;
+    constructor(el: ElementRef, navSelectorGroupPresenter: NavSelectorGroupPresenter);
+    maxHeight: import("@angular/core").WritableSignal<string>;
+    onKeydownSpaceOrEnter($event: Event): void;
+    toggleFolding(event: Event): void;
+    fold(event: Event): void;
+    unfold(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorGroupComponent, "ap-nav-selector-group", never, { "group": { "alias": "group"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/nav-selector/nav-selector-group/nav-selector-group.presenter.d.ts

@@ -0,0 +1,17 @@
+import { InternalNavSelectorGroup } from '../nav-selector';
+import { NavSelectorState } from '../nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorGroupPresenter {
+    private navSelectorState;
+    expanded: import("@angular/core").Signal<boolean>;
+    texts: import("@angular/core").Signal<import("../nav-selector").NavSelectorTranslatedTexts>;
+    isMultipleModeEnabled: import("@angular/core").Signal<boolean>;
+    expandedAfterDelay: import("@angular/core").Signal<boolean>;
+    constructor(navSelectorState: NavSelectorState);
+    onGroupSelected(group: InternalNavSelectorGroup): void;
+    onGroupToggleFolding(group: InternalNavSelectorGroup): void;
+    fold(group: InternalNavSelectorGroup): void;
+    unfold(group: InternalNavSelectorGroup): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorGroupPresenter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorGroupPresenter>;
+}

package/nav-selector/nav-selector-leaf/nav-selector-leaf.component.d.ts

@@ -0,0 +1,51 @@
+import { ElementRef } from '@angular/core';
+import { MatMenuTrigger } from '@angular/material/menu';
+import { InternalNavSelectorLeaf } from '../nav-selector';
+import { NavSelectorLeafPresenter } from './nav-selector-leaf.presenter';
+import * as i0 from "@angular/core";
+export declare class NavSelectorLeafComponent {
+    private el;
+    navSelectorLeafPresenter: NavSelectorLeafPresenter;
+    leaf: import("@angular/core").InputSignal<InternalNavSelectorLeaf>;
+    initial: import("@angular/core").Signal<string>;
+    foldSymbol: import("@angular/core").Signal<"chevron-down" | "chevron-up">;
+    hovering: import("@angular/core").WritableSignal<boolean>;
+    hoveringMenu: import("@angular/core").WritableSignal<boolean>;
+    onlyButtonDisplayed: import("@angular/core").Signal<boolean>;
+    aliasEl: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    aliasBoundedClientRect: import("@angular/core").WritableSignal<{
+        offsetWidth: number;
+        offsetHeight: number;
+        scrollWidth: number;
+        scrollHeight: number;
+    }>;
+    tooltipContent: import("@angular/core").Signal<string>;
+    tooltipDisabled: import("@angular/core").Signal<boolean>;
+    minifiedEl: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    menuEl: import("@angular/core").Signal<ElementRef<any> | undefined>;
+    menuTriggerEl: import("@angular/core").Signal<MatMenuTrigger | undefined>;
+    actionMenuTriggerEl: import("@angular/core").Signal<MatMenuTrigger | undefined>;
+    foldedWithDelay: import("@angular/core").WritableSignal<boolean>;
+    network: import("@angular/core").Signal<"bluesky" | "facebook" | "instagram" | "linkedin" | "twitter" | "youtube" | "meta" | "google" | "pinterest" | "threads" | "tiktok" | "webBlog" | "webNews" | "X" | null | undefined>;
+    constructor(el: ElementRef, navSelectorLeafPresenter: NavSelectorLeafPresenter);
+    animationState: import("@angular/core").Signal<"collapsed" | "expanded">;
+    maxHeight: import("@angular/core").WritableSignal<string>;
+    onClick($event: Event): void;
+    toggleFolding(event: Event): void;
+    mouseEntered(): void;
+    mouseLeft($event: MouseEvent): void;
+    mouseEnteredMenu(): void;
+    mouseLeftMenu(menuTrigger: MatMenuTrigger, $event: MouseEvent): void;
+    menuOpened(): void;
+    onActionButtonClick($event: Event): void;
+    onActionButtonKeyDownSpaceOrEnter($event: Event): void;
+    selectOnly(event: Event): void;
+    onCheckboxToggle(): void;
+    onSpaceOrEnterPressed($event: Event): void;
+    fold(event: Event): void;
+    unfold(event: Event): void;
+    private tryCloseMenu;
+    private mouseIsHovering;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorLeafComponent, "ap-nav-selector-leaf", never, { "leaf": { "alias": "leaf"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/nav-selector/nav-selector-leaf/nav-selector-leaf.presenter.d.ts

@@ -0,0 +1,19 @@
+import { InternalNavSelectorLeaf } from '../nav-selector';
+import { NavSelectorState } from '../nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorLeafPresenter {
+    private navSelectorState;
+    expanded: import("@angular/core").Signal<boolean>;
+    texts: import("@angular/core").Signal<import("../nav-selector").NavSelectorTranslatedTexts>;
+    isMultipleModeEnabled: import("@angular/core").Signal<boolean>;
+    leafActionProjection: import("@angular/core").Signal<readonly import("@angular/core").TemplateRef<unknown>[] | undefined>;
+    expandedAfterDelay: import("@angular/core").Signal<boolean>;
+    constructor(navSelectorState: NavSelectorState);
+    onLeafClicked(leaf: InternalNavSelectorLeaf): void;
+    onLeafToggleFolding(leaf: InternalNavSelectorLeaf): void;
+    selectOnlyLeaf(leaf: InternalNavSelectorLeaf): void;
+    fold(leaf: InternalNavSelectorLeaf): void;
+    unfold(leaf: InternalNavSelectorLeaf): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafPresenter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorLeafPresenter>;
+}

package/nav-selector/nav-selector-leaf-detail/nav-selector-leaf-detail.component.d.ts

@@ -0,0 +1,13 @@
+import { InternalNavSelectorLeafDetails } from '../nav-selector';
+import { NavSelectorLeafDetailPresenter } from './nav-selector-leaf-detail.presenter';
+import * as i0 from "@angular/core";
+import * as i1 from "../directives/tree-node-accessibility.directive";
+export declare class NavSelectorLeafDetailComponent {
+    navSelectorLeafDetailPresenter: NavSelectorLeafDetailPresenter;
+    detail: import("@angular/core").InputSignal<InternalNavSelectorLeafDetails>;
+    embedded: import("@angular/core").InputSignal<boolean>;
+    constructor(navSelectorLeafDetailPresenter: NavSelectorLeafDetailPresenter);
+    onClick($event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafDetailComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorLeafDetailComponent, "ap-nav-selector-leaf-detail", never, { "detail": { "alias": "detail"; "required": true; "isSignal": true; }; "embedded": { "alias": "embedded"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.TreeNodeAccessibilityDirective; inputs: { "apTreeNodeAccessibility": "detail"; }; outputs: {}; }]>;
+}

package/nav-selector/nav-selector-leaf-detail/nav-selector-leaf-detail.presenter.d.ts

@@ -0,0 +1,10 @@
+import { InternalNavSelectorLeafDetails } from '../nav-selector';
+import { NavSelectorState } from '../nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorLeafDetailPresenter {
+    private navSelectorState;
+    constructor(navSelectorState: NavSelectorState);
+    onLeafDetailClicked(detail: InternalNavSelectorLeafDetails): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafDetailPresenter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorLeafDetailPresenter>;
+}

package/nav-selector/nav-selector-leaf-details/nav-selector-leaf-details.component.d.ts

@@ -0,0 +1,24 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { InternalNavSelectorLeaf, InternalNavSelectorLeafDetails } from '../nav-selector';
+import { NavSelectorLeafDetailsPresenter } from '../nav-selector-leaf-details/nav-selector-leaf-details.presenter';
+import * as i0 from "@angular/core";
+export declare class NavSelectorLeafDetailsComponent implements AfterViewInit {
+    private el;
+    navSelectorLeafDetailsPresenter: NavSelectorLeafDetailsPresenter;
+    leaf: import("@angular/core").InputSignal<InternalNavSelectorLeaf>;
+    details: import("@angular/core").InputSignal<InternalNavSelectorLeafDetails[]>;
+    firstDetails: import("@angular/core").Signal<InternalNavSelectorLeafDetails[]>;
+    lastDetails: import("@angular/core").Signal<InternalNavSelectorLeafDetails[]>;
+    viewMoreDelay: import("@angular/core").WritableSignal<boolean>;
+    animationState: import("@angular/core").Signal<"collapsed" | "expanded">;
+    /**
+     * The height when details are all displayed
+     */
+    maxHeight: import("@angular/core").WritableSignal<string>;
+    constructor(el: ElementRef, navSelectorLeafDetailsPresenter: NavSelectorLeafDetailsPresenter);
+    ngAfterViewInit(): void;
+    toggleViewMore(): void;
+    onSpaceOrEnter(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafDetailsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorLeafDetailsComponent, "ap-nav-selector-leaf-details", never, { "leaf": { "alias": "leaf"; "required": true; "isSignal": true; }; "details": { "alias": "details"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/nav-selector/nav-selector-leaf-details/nav-selector-leaf-details.presenter.d.ts

@@ -0,0 +1,14 @@
+import { InternalNavSelectorLeaf } from '../nav-selector';
+import { NavSelectorState } from '../nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorLeafDetailsPresenter {
+    private navSelectorState;
+    viewMoreText: import("@angular/core").Signal<string>;
+    viewLessText: import("@angular/core").Signal<string>;
+    constructor(navSelectorState: NavSelectorState);
+    toggleViewMore(leaf: InternalNavSelectorLeaf): void;
+    viewMore(leaf: InternalNavSelectorLeaf): void;
+    viewLess(leaf: InternalNavSelectorLeaf): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorLeafDetailsPresenter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorLeafDetailsPresenter>;
+}

package/nav-selector/nav-selector.component.d.ts

@@ -0,0 +1,29 @@
+import { ElementRef, TemplateRef } from '@angular/core';
+import { NavSelectorEntry, NavSelectorTranslatedTexts } from './nav-selector';
+import { NavSelectorState } from './nav-selector.state';
+import * as i0 from "@angular/core";
+export declare class NavSelectorComponent {
+    navSelectorState: NavSelectorState;
+    private el;
+    navSelectorEntries: import("@angular/core").InputSignal<NavSelectorEntry[]>;
+    translatedTexts: import("@angular/core").InputSignal<NavSelectorTranslatedTexts>;
+    multipleModeEnabled: import("@angular/core").InputSignal<boolean>;
+    detailsDisplayedLimit: import("@angular/core").InputSignal<number>;
+    /**
+     * If true, the nav selector will be expanded by default. Even if the width of the screen is smaller than 1280px.
+     */
+    forceExpanded: import("@angular/core").InputSignal<boolean>;
+    selectedEntryUids: import("@angular/core").ModelSignal<string[]>;
+    headerProjection: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+    footerProjection: import("@angular/core").Signal<TemplateRef<unknown> | undefined>;
+    displayFooter: import("@angular/core").Signal<boolean>;
+    leafActionProjection: import("@angular/core").Signal<readonly TemplateRef<unknown>[]>;
+    expansionState: import("@angular/core").Signal<"expanded" | "minified">;
+    componentUid: string;
+    constructor(navSelectorState: NavSelectorState, el: ElementRef);
+    onArrowDown($event: Event): void;
+    onArrowUp($event: Event): void;
+    protected readonly TemplateRef: typeof TemplateRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NavSelectorComponent, "ap-nav-selector", never, { "navSelectorEntries": { "alias": "navSelectorEntries"; "required": true; "isSignal": true; }; "translatedTexts": { "alias": "translatedTexts"; "required": true; "isSignal": true; }; "multipleModeEnabled": { "alias": "multipleModeEnabled"; "required": false; "isSignal": true; }; "detailsDisplayedLimit": { "alias": "detailsDisplayedLimit"; "required": false; "isSignal": true; }; "forceExpanded": { "alias": "forceExpanded"; "required": false; "isSignal": true; }; "selectedEntryUids": { "alias": "selectedEntryUids"; "required": true; "isSignal": true; }; }, { "selectedEntryUids": "selectedEntryUidsChange"; }, ["headerProjection", "footerProjection", "leafActionProjection"], never, true, never>;
+}

package/nav-selector/nav-selector.d.ts

@@ -0,0 +1,220 @@
+import { AvatarNetwork } from '@agorapulse/ui-components/avatar';
+/**
+ * As translation is not available in the DS, this all translations needed
+ */
+export interface NavSelectorTranslatedTexts {
+    /** Title of the nav selector */
+    title: string;
+    /** Only text in multi select mode */
+    only: string;
+    /** Toolip displaying that token is invalid */
+    tokenInvalid: string;
+    /** Toolip displaying that feature is locked */
+    featureLocked: string;
+    /** placeholder for the search input */
+    searchPlaceholder: string;
+    /** Text displayed when the search return no results */
+    noResults: string;
+    /** Text of the button to show more details, it’s used when we limit the number of details displayed  */
+    viewMore: string;
+    /** Text of the button to show less details, it’s used when we limit the number of details displayed  */
+    viewLess: string;
+}
+/**
+ * Common interface for the NavSelector
+ */
+export type NavSelectorBaseNode = {
+    /** Unique identifier of the node */
+    uid: string;
+    /** Displayed name of the node */
+    alias: string;
+};
+/**
+ * Represent final entry of the nav selector
+ */
+export type NavSelectorLeaf = {
+    pictureUrl: string | null;
+    /** Counter to display on the entry, to ignore if the leaf has details */
+    counter: number | null;
+    /** When true, the leaf will be hidden */
+    missingPermission: boolean;
+    /** For social profiles or ad accounts the corresponding network */
+    network: AvatarNetwork | null;
+    /** Translated text when the entry is disabled */
+    disableReason: string | null;
+    /** Indicates if entry has its token invalid */
+    tokenInvalid: boolean;
+    /** Indicates if entry is locked */
+    featureLocked: boolean;
+    /** Sub elements of the leaf, they are optional */
+    details: NavSelectorLeafDetails[];
+    type: 'LEAF';
+} & NavSelectorBaseNode;
+/**
+ * Represent a group of entries which has been created by the user (ex: menuGroup)
+ */
+export type NavSelectorGroup = {
+    /** A group can only have leaves as children */
+    children: NavSelectorLeaf[];
+    /** Indicates if the group should be folded or expanded when generating the nav selector */
+    folded: boolean;
+    type: 'GROUP';
+} & NavSelectorBaseNode;
+/**
+ * Represent a category of entries which has been created by the product to separate different kind of entries (ex: social profiles, reports, ad accounts…)
+ */
+export type NavSelectorCategory = {
+    /** A Category can have leaves or groups as children, you can have leaves alongside with groups */
+    children: (NavSelectorLeaf | NavSelectorGroup)[];
+    /** Indicates if the group should be folded or expanded when generating the nav selector */
+    folded: boolean;
+    type: 'CATEGORY';
+} & NavSelectorBaseNode;
+export type NavSelectorEntry = NavSelectorLeaf | NavSelectorGroup | NavSelectorCategory;
+/**
+ * Represent details of a leaf, they are used to allow to display more specific information about the leaf
+ */
+export interface NavSelectorLeafDetails {
+    /** Unique identifier of the node */
+    uid: string;
+    /** Counter to display on the entry */
+    counter: number | null;
+    /** Displayed name of the node */
+    name: string;
+    /** Translation of the error on the leaf */
+    errorReason: string | null;
+}
+export declare const isNavSelectorEntryALeaf: (entry: NavSelectorEntry) => entry is NavSelectorLeaf;
+export declare const isNavSelectorEntryAGroup: (entry: NavSelectorEntry) => entry is NavSelectorGroup;
+export declare const isNavSelectorEntryACategory: (entry: NavSelectorEntry) => entry is NavSelectorCategory;
+/**
+ * Represent the accessibility on a node
+ */
+export type NodeAccessibility = {
+    /** Number of sibling elements, itself included. Ex: there are 7 social profiles display in the group */
+    ariaSetsize: number;
+    /** Index starting from 1 of the element alongside its sibling */
+    ariaPosinset: number;
+    /** 0 to be focusable by Tab key and -1 to be focusable by keyboard with JS */
+    tabIndex: number;
+    /** In a tree, the deep level, starting from 1 */
+    ariaLevel: number;
+};
+/**
+ * Represent a node
+ */
+export type InternalNavSelectorBaseNode = {
+    /** Unique identifier of the entry */
+    uid: string;
+    /** Displayed name of the entry */
+    alias: string;
+    accessibility: NodeAccessibility;
+    /** When hidden, the entry is not displayed, used when searching an element */
+    hidden: boolean;
+    /** When true, you can navigate with arrow keys on this entry */
+    focusable: boolean;
+};
+/**
+ * Represent a group of entries which has been created by the user (ex: menuGroup)
+ */
+export type InternalNavSelectorGroup = {
+    /** A group can only have leaves as children */
+    children: InternalNavSelectorLeaf[];
+    /** Picture url of the group, used when the nav selector is minified */
+    childrenPictureUrlSample: {
+        url: string | null;
+        initial: string;
+    }[];
+    /** Indicates whenever the group is folded or not */
+    folded: boolean;
+    /** Indicates the counter value to display when the group is folded */
+    counter: number;
+    /** Indicates if the counter should be display when the group is folded */
+    displayCounter: boolean;
+    /** Indicates if the token invalid icon should be display when the group is folded */
+    displayTokenInvalid: boolean;
+    /** Indicates in multi select mode if the group has some children selected */
+    undeterminedSelection: boolean;
+    /** Indicates if the group is selected */
+    selected: boolean;
+    /** Indicates if the group is selectable */
+    selectable: boolean;
+    type: 'GROUP';
+} & InternalNavSelectorBaseNode;
+/**
+ * Represent a category of entries which has been created by the product to separate different kind of entries (ex: social profiles, reports, ad accounts…)
+ */
+export type InternalNavSelectorCategory = {
+    /** A Category can have leaves or groups as children, you can have leaves alongside with groups */
+    children: (InternalNavSelectorGroup | InternalNavSelectorLeaf)[];
+    /** Indicates whenever the category is folded or not */
+    folded: boolean;
+    type: 'CATEGORY';
+} & InternalNavSelectorBaseNode;
+/**
+ * Represent final entry of the nav selector
+ */
+export type InternalNavSelectorLeaf = {
+    pictureUrl: string | null;
+    /** Indicates if the counter could be display. The leaf should not be disabled, feature locked or has token invalid */
+    counterDisplayable: boolean;
+    /** Indicates if the token invalid icon should be display. So when displayable when no details or folded */
+    displayCounter: boolean;
+    /** Counter value to display */
+    counter: number;
+    /** Indicates if the token invalid icon should be display */
+    displayTokenInvalid: boolean;
+    /** Indicates if the feature is locked */
+    displayFeatureLocked: boolean;
+    /** Indicates if the leaf is disabled */
+    disabled: boolean;
+    /** The disabled reason to display in tooltip */
+    disableReason: string | null;
+    /** Indicates if the leaf is selected */
+    selected: boolean;
+    /** Indicates if the leaf is selectable */
+    selectable: boolean;
+    /** For social profiles or ad accounts, the corresponding network */
+    network: AvatarNetwork | null;
+    /** Indicates if the leaf foldable. So when it has details and no error status */
+    foldable: boolean;
+    /** Indicates if the leaf is folded */
+    folded: boolean;
+    /** Indicates if the leaf has details and they are displayable. So no error status */
+    detailsDisplayable: boolean;
+    /** Details of the leaf */
+    details: InternalNavSelectorLeafDetails[];
+    type: 'LEAF';
+    /** Indicates if the view more section should be display for details */
+    viewMoreDisplayable: boolean;
+    /** Indicates if the view more or view less button is displayed */
+    viewMoreDisplayed: boolean;
+    /** Number of details to display when the view more is not clicked */
+    viewMoreDetailsDisplayedLimit: number;
+} & InternalNavSelectorBaseNode;
+/**
+ * Represent details of a leaf, they are used to allow to display more specific information about the leaf
+ */
+export type InternalNavSelectorLeafDetails = {
+    /** Unique identifier of the node */
+    uid: string;
+    /** Counter to display on the detail */
+    counter: number;
+    /** Indicates if the counter should be display. So no error on the detail */
+    displayCounter: boolean;
+    /** Displayed name of the node */
+    alias: string;
+    /** Indicates if the detail is selected */
+    selected: boolean;
+    /** Indicates if we should display an error icon */
+    displayError: boolean;
+    /** Translated text to display in the tooltip */
+    errorReason: string | null;
+    type: 'LEAF_DETAILS';
+} & InternalNavSelectorBaseNode;
+export type InternalNavSelectorEntry = InternalNavSelectorLeaf | InternalNavSelectorGroup | InternalNavSelectorCategory | InternalNavSelectorLeafDetails;
+export declare const isInternalNavSelectorEntryALeaf: (entry: InternalNavSelectorEntry) => entry is InternalNavSelectorLeaf;
+export declare const isInternalNavSelectorEntryANode: (entry: InternalNavSelectorEntry) => entry is InternalNavSelectorCategory | InternalNavSelectorGroup;
+export declare const isInternalNavSelectorEntryACategory: (entry: InternalNavSelectorEntry) => entry is InternalNavSelectorCategory;
+export declare const isInternalNavSelectorEntryAGroup: (entry: InternalNavSelectorEntry) => entry is InternalNavSelectorGroup;
+export declare const isInternalNavSelectorEntryALeafDetails: (entry: InternalNavSelectorEntry) => entry is InternalNavSelectorLeafDetails;

package/nav-selector/nav-selector.state.d.ts

@@ -0,0 +1,47 @@
+import { TemplateRef } from '@angular/core';
+import { InternalNavSelectorEntry, InternalNavSelectorLeaf, InternalNavSelectorLeafDetails, NavSelectorEntry, NavSelectorTranslatedTexts } from './nav-selector';
+import * as i0 from "@angular/core";
+/**
+ * NavSelectorState is a service that manages the state of the nav selector.
+ *
+ * It should be provided by the component to ensure that if many nav selectors are used in the same page, they don't share the same state.
+ */
+export declare class NavSelectorState {
+    private entries;
+    private multipleModeEnabled;
+    private _texts;
+    private lastSelectedUids;
+    isMultipleModeEnabled: import("@angular/core").WritableSignal<boolean>;
+    search: import("@angular/core").WritableSignal<string>;
+    filteredEntries: import("@angular/core").Signal<InternalNavSelectorEntry[]>;
+    noResults: import("@angular/core").Signal<boolean>;
+    texts: import("@angular/core").Signal<NavSelectorTranslatedTexts>;
+    leafActionProjection: import("@angular/core").WritableSignal<readonly TemplateRef<unknown>[] | undefined>;
+    expanded: import("@angular/core").WritableSignal<boolean>;
+    expandedAfterDelay: import("@angular/core").WritableSignal<boolean>;
+    selectedUidsChangeCallback: ((selectedUids: string[]) => void) | null;
+    constructor();
+    updateMultiModeEnabled(enabled: boolean): void;
+    updateEntries(entries: NavSelectorEntry[], initialSelectedEntryUids: string[], detailsDisplayedLimit: number): void;
+    onGroupToggleFolding(group: InternalNavSelectorEntry): void;
+    onNodeSelect(node: InternalNavSelectorEntry): void;
+    onLeafClicked(leaf: InternalNavSelectorLeaf): void;
+    onLeafToggleFolding(leaf: InternalNavSelectorEntry): void;
+    onLeafDetailClicked(leafDetail: InternalNavSelectorLeafDetails): void;
+    updateTexts(texts: NavSelectorTranslatedTexts): void;
+    selectOnlyLeaf(leaf: InternalNavSelectorLeaf): void;
+    toggleExpanded(): void;
+    onSelectionChange(uids: string[]): void;
+    registerOnSelectedUidsChange(callback: (selectedUids: string[]) => void): void;
+    onArrowDown(): void;
+    onArrowUp(): void;
+    private collectSelectedUids;
+    updateLeafAction(leafActionProjection: ReadonlyArray<TemplateRef<unknown>>): void;
+    fold(entry: InternalNavSelectorEntry): void;
+    unfold(entry: InternalNavSelectorEntry): void;
+    updateDetailsDisplayedLimit(detailsDisplayedLimit: number): void;
+    viewMore(leaf: InternalNavSelectorLeaf): void;
+    viewLess(leaf: InternalNavSelectorLeaf): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavSelectorState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavSelectorState>;
+}

package/nav-selector/public_api.d.ts

@@ -0,0 +1,2 @@
+export { NavSelectorCategory, NavSelectorGroup, NavSelectorLeaf, NavSelectorLeafDetails, NavSelectorTranslatedTexts, NodeAccessibility, } from './nav-selector';
+export * from './nav-selector.component';

package/nav-selector/utils/leaf.utils.d.ts

@@ -0,0 +1,5 @@
+import { InternalNavSelectorLeaf } from '../nav-selector';
+export declare const isInternalNavSelectorEntryALeafFocusable: (leaf: InternalNavSelectorLeaf, { parentFolded, minified }: {
+    parentFolded: boolean;
+    minified: boolean;
+}) => boolean;

package/nav-selector/utils/nav-selector.accessibility.d.ts

@@ -0,0 +1,52 @@
+import { InternalNavSelectorEntry } from '../nav-selector';
+/**
+ * NavSelectorAccessibility is a utility class that provides methods to manage the accessibility and the focusability of nav selector entries.
+ */
+export declare class NavSelectorAccessibility {
+    /**
+     * Set tabIndex to 0 for the first focusable entry and -1 for all other entries
+     * @param entries nav selector entries
+     */
+    static resetFocus(entries: InternalNavSelectorEntry[]): InternalNavSelectorEntry[];
+    /**
+     * Focus the given entry and set tabIndex to 0 for the given uid and -1 for all other entries
+     * @param entries nav selector entries
+     * @param uid the uid of the entry to focus
+     */
+    static focus<T extends InternalNavSelectorEntry>(entries: T[], uid: string): InternalNavSelectorEntry[];
+    /**
+     * Unfocus the given entry and set tabIndex to -1 for the given uid and 0 for all other entries
+     * @param entries nav selector entries
+     * @param uid the uid of the entry to unfocus
+     */
+    static unfocus(entries: InternalNavSelectorEntry[], uid: string): InternalNavSelectorEntry[];
+    /**
+     * Focus the previous entry focusable and set tabIndex to 0 for the previous focusable entry and -1 for all other entries
+     *
+     * If not previous entries are focusable, entries will not be modified
+     *
+     * @param entries nav selector entries
+     */
+    static focusPrevious<T extends InternalNavSelectorEntry>(entries: T[]): InternalNavSelectorEntry[];
+    /**
+     * Focus the next entry focusable and set tabIndex to 0 for the next focusable entry and -1 for all other entries
+     *
+     * If not next entries are focusable, entries will not be modified
+     *
+     * @param entries nav selector entries
+     */
+    static focusNext<T extends InternalNavSelectorEntry>(entries: T[]): InternalNavSelectorEntry[];
+    private static previousEntryIsFirstAndNotFocusable;
+    private static focusAnEntry;
+    private static unfocusAnEntry;
+    /**
+     * Flatten the nav selector entries. It is easier to work with flat entries for the focus management as we need to know which is the previous or the next entry
+     * @param entries nav selector entries
+     */
+    private static flatten;
+    /**
+     * Unflatten the nav selector entries
+     * @param entries nav selector entries
+     */
+    private static unflatten;
+}