@agorapulse/ui-components 18.0.9 → 18.0.11

package/esm2022/nav-selector/nav-selector.state.mjs

@@ -0,0 +1,173 @@
+import { computed, effect, Injectable, signal } from '@angular/core';
+import { isInternalNavSelectorEntryALeaf, isInternalNavSelectorEntryANode, } from './nav-selector';
+import { NavSelectorAccessibility } from './utils/nav-selector.accessibility';
+import { NavSelectorBuilder } from './utils/nav-selector.builder';
+import { NavSelectorFilter } from './utils/nav-selector.filter';
+import { NavSelectorFolding } from './utils/nav-selector.folding';
+import { NavSelectorMinifying } from './utils/nav-selector.minifying';
+import { NavSelectorMultiSelect } from './utils/nav-selector.multi-select';
+import { NavSelectorSingleSelect } from './utils/nav-selector.single-select';
+import { NavSelectorViewMore } from './utils/nav-selector.view-more';
+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 class NavSelectorState {
+    entries = signal([]);
+    multipleModeEnabled = signal(false);
+    _texts = signal({
+        title: '',
+        only: '',
+        tokenInvalid: '',
+        featureLocked: '',
+        searchPlaceholder: '',
+        noResults: '',
+        viewMore: '',
+        viewLess: '',
+    });
+    lastSelectedUids = signal([]);
+    isMultipleModeEnabled = this.multipleModeEnabled;
+    search = signal('');
+    filteredEntries = computed(() => NavSelectorFilter.filter(this.entries(), this.search()));
+    noResults = computed(() => this.filteredEntries().every(({ hidden }) => hidden));
+    texts = this._texts.asReadonly();
+    leafActionProjection = signal(undefined);
+    expanded = signal(true);
+    expandedAfterDelay = signal(true);
+    selectedUidsChangeCallback = null;
+    constructor() {
+        effect(() => {
+            const newSelectedUids = this.collectSelectedUids(this.entries());
+            if (this.selectedUidsChangeCallback) {
+                this.selectedUidsChangeCallback(newSelectedUids);
+            }
+        }, { allowSignalWrites: true });
+    }
+    updateMultiModeEnabled(enabled) {
+        this.multipleModeEnabled.set(enabled);
+    }
+    updateEntries(entries, initialSelectedEntryUids, detailsDisplayedLimit) {
+        if (this.multipleModeEnabled()) {
+            this.entries.set(NavSelectorBuilder.buildInMultipleMode(entries, initialSelectedEntryUids, detailsDisplayedLimit));
+        }
+        else {
+            this.entries.set(NavSelectorBuilder.build(entries, initialSelectedEntryUids?.[0] ?? null, detailsDisplayedLimit));
+        }
+    }
+    onGroupToggleFolding(group) {
+        this.entries.update(entries => NavSelectorFolding.toggleFolding(entries, group.uid, !this.expanded()));
+    }
+    onNodeSelect(node) {
+        this.entries.update(entries => NavSelectorMultiSelect.selectInMultipleMode(entries, node.uid));
+    }
+    onLeafClicked(leaf) {
+        if (!leaf.selectable) {
+            return;
+        }
+        if (this.multipleModeEnabled()) {
+            this.entries.update(entries => NavSelectorMultiSelect.selectInMultipleMode(entries, leaf.uid));
+        }
+        else {
+            this.entries.update(entries => NavSelectorSingleSelect.select(entries, leaf.uid));
+        }
+    }
+    onLeafToggleFolding(leaf) {
+        this.entries.update(entries => NavSelectorFolding.toggleFolding(entries, leaf.uid, !this.expanded()));
+    }
+    onLeafDetailClicked(leafDetail) {
+        this.entries.update(entries => NavSelectorSingleSelect.select(entries, leafDetail.uid));
+    }
+    updateTexts(texts) {
+        this._texts.set(texts);
+    }
+    selectOnlyLeaf(leaf) {
+        this.entries.update(entries => NavSelectorMultiSelect.selectOnlyALeafInMultipleMode(entries, leaf.uid));
+    }
+    toggleExpanded() {
+        this.expanded.update(expanded => !expanded);
+        this.entries.update(entries => {
+            if (this.expanded()) {
+                return NavSelectorMinifying.expand(entries);
+            }
+            return NavSelectorMinifying.minify(entries);
+        });
+        if (!this.expanded()) {
+            setTimeout(() => this.expandedAfterDelay.set(this.expanded()), 150);
+        }
+        else {
+            this.expandedAfterDelay.set(this.expanded());
+        }
+    }
+    onSelectionChange(uids) {
+        // Avoid infinite loop if you put unexisting uids as select will generate the same entries but with different reference
+        if (JSON.stringify(uids) === JSON.stringify(this.lastSelectedUids())) {
+            return;
+        }
+        this.lastSelectedUids.set(uids);
+        const selectedUids = this.collectSelectedUids(this.entries());
+        const uidToSelect = uids.filter(uid => selectedUids.every(selectedUid => selectedUid !== uid));
+        const uidToUnselect = selectedUids.filter(uid => uids.every(selectedUid => selectedUid !== uid));
+        if (!uidToSelect.length && !uidToUnselect.length) {
+            return;
+        }
+        let entries = this.entries();
+        if (this.multipleModeEnabled()) {
+            for (const uid of [...uidToSelect, ...uidToUnselect]) {
+                entries = NavSelectorMultiSelect.selectInMultipleMode(entries, uid);
+            }
+        }
+        else {
+            entries = NavSelectorSingleSelect.select(entries, uids[0]);
+        }
+        this.entries.set(entries);
+    }
+    registerOnSelectedUidsChange(callback) {
+        this.selectedUidsChangeCallback = callback;
+    }
+    onArrowDown() {
+        this.entries.update(entries => NavSelectorAccessibility.focusNext(entries));
+    }
+    onArrowUp() {
+        this.entries.update(entries => NavSelectorAccessibility.focusPrevious(entries));
+    }
+    collectSelectedUids(entries) {
+        return entries.flatMap(entry => {
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                if (entry.details.length) {
+                    return entry.details.flatMap(detail => (detail.selected ? [detail.uid] : []));
+                }
+                return entry.selected ? [entry.uid] : [];
+            }
+            else if (isInternalNavSelectorEntryANode(entry)) {
+                return this.collectSelectedUids(entry.children);
+            }
+            return [];
+        });
+    }
+    updateLeafAction(leafActionProjection) {
+        this.leafActionProjection.set(leafActionProjection);
+    }
+    fold(entry) {
+        this.entries.update(entries => NavSelectorFolding.fold(entries, entry.uid, !this.expanded()));
+    }
+    unfold(entry) {
+        this.entries.update(entries => NavSelectorFolding.unfold(entries, entry.uid, !this.expanded()));
+    }
+    updateDetailsDisplayedLimit(detailsDisplayedLimit) {
+        this.entries.update(entries => NavSelectorViewMore.changeViewMoreDetailsDisplayedLimit(entries, detailsDisplayedLimit));
+    }
+    viewMore(leaf) {
+        this.entries.update(entries => NavSelectorViewMore.viewMore(entries, leaf.uid));
+    }
+    viewLess(leaf) {
+        this.entries.update(entries => NavSelectorViewMore.viewLess(entries, leaf.uid));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NavSelectorState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NavSelectorState });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: NavSelectorState, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-selector.state.js","sourceRoot":"","sources":["../../../../libs/ui-components/nav-selector/src/nav-selector.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, effect, Injectable, signal, TemplateRef } from '@angular/core';\nimport {\n    InternalNavSelectorEntry,\n    InternalNavSelectorLeaf,\n    InternalNavSelectorLeafDetails,\n    isInternalNavSelectorEntryALeaf,\n    isInternalNavSelectorEntryANode,\n    NavSelectorEntry,\n    NavSelectorTranslatedTexts,\n} from './nav-selector';\nimport { NavSelectorAccessibility } from './utils/nav-selector.accessibility';\nimport { NavSelectorBuilder } from './utils/nav-selector.builder';\nimport { NavSelectorFilter } from './utils/nav-selector.filter';\nimport { NavSelectorFolding } from './utils/nav-selector.folding';\nimport { NavSelectorMinifying } from './utils/nav-selector.minifying';\nimport { NavSelectorMultiSelect } from './utils/nav-selector.multi-select';\nimport { NavSelectorSingleSelect } from './utils/nav-selector.single-select';\nimport { NavSelectorViewMore } from './utils/nav-selector.view-more';\n\n/**\n * NavSelectorState is a service that manages the state of the nav selector.\n *\n * 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.\n */\n@Injectable()\nexport class NavSelectorState {\n    private entries = signal<InternalNavSelectorEntry[]>([]);\n    private multipleModeEnabled = signal<boolean>(false);\n    private _texts = signal<NavSelectorTranslatedTexts>({\n        title: '',\n        only: '',\n        tokenInvalid: '',\n        featureLocked: '',\n        searchPlaceholder: '',\n        noResults: '',\n        viewMore: '',\n        viewLess: '',\n    });\n    private lastSelectedUids = signal<string[]>([]);\n\n    isMultipleModeEnabled = this.multipleModeEnabled;\n    search = signal<string>('');\n    filteredEntries = computed(() => NavSelectorFilter.filter(this.entries(), this.search()));\n    noResults = computed(() => this.filteredEntries().every(({ hidden }) => hidden));\n    texts = this._texts.asReadonly();\n\n    leafActionProjection = signal<ReadonlyArray<TemplateRef<unknown>> | undefined>(undefined);\n\n    expanded = signal(true);\n    expandedAfterDelay = signal(true);\n\n    selectedUidsChangeCallback: ((selectedUids: string[]) => void) | null = null;\n\n    constructor() {\n        effect(\n            () => {\n                const newSelectedUids = this.collectSelectedUids(this.entries());\n                if (this.selectedUidsChangeCallback) {\n                    this.selectedUidsChangeCallback(newSelectedUids);\n                }\n            },\n            { allowSignalWrites: true }\n        );\n    }\n\n    updateMultiModeEnabled(enabled: boolean) {\n        this.multipleModeEnabled.set(enabled);\n    }\n\n    updateEntries(entries: NavSelectorEntry[], initialSelectedEntryUids: string[], detailsDisplayedLimit: number) {\n        if (this.multipleModeEnabled()) {\n            this.entries.set(NavSelectorBuilder.buildInMultipleMode(entries, initialSelectedEntryUids, detailsDisplayedLimit));\n        } else {\n            this.entries.set(NavSelectorBuilder.build(entries, initialSelectedEntryUids?.[0] ?? null, detailsDisplayedLimit));\n        }\n    }\n\n    onGroupToggleFolding(group: InternalNavSelectorEntry) {\n        this.entries.update(entries => NavSelectorFolding.toggleFolding(entries, group.uid, !this.expanded()));\n    }\n\n    onNodeSelect(node: InternalNavSelectorEntry) {\n        this.entries.update(entries => NavSelectorMultiSelect.selectInMultipleMode(entries, node.uid));\n    }\n\n    onLeafClicked(leaf: InternalNavSelectorLeaf) {\n        if (!leaf.selectable) {\n            return;\n        }\n        if (this.multipleModeEnabled()) {\n            this.entries.update(entries => NavSelectorMultiSelect.selectInMultipleMode(entries, leaf.uid));\n        } else {\n            this.entries.update(entries => NavSelectorSingleSelect.select(entries, leaf.uid));\n        }\n    }\n\n    onLeafToggleFolding(leaf: InternalNavSelectorEntry) {\n        this.entries.update(entries => NavSelectorFolding.toggleFolding(entries, leaf.uid, !this.expanded()));\n    }\n\n    onLeafDetailClicked(leafDetail: InternalNavSelectorLeafDetails) {\n        this.entries.update(entries => NavSelectorSingleSelect.select(entries, leafDetail.uid));\n    }\n\n    updateTexts(texts: NavSelectorTranslatedTexts) {\n        this._texts.set(texts);\n    }\n\n    selectOnlyLeaf(leaf: InternalNavSelectorLeaf) {\n        this.entries.update(entries => NavSelectorMultiSelect.selectOnlyALeafInMultipleMode(entries, leaf.uid));\n    }\n\n    toggleExpanded() {\n        this.expanded.update(expanded => !expanded);\n        this.entries.update(entries => {\n            if (this.expanded()) {\n                return NavSelectorMinifying.expand(entries);\n            }\n            return NavSelectorMinifying.minify(entries);\n        });\n        if (!this.expanded()) {\n            setTimeout(() => this.expandedAfterDelay.set(this.expanded()), 150);\n        } else {\n            this.expandedAfterDelay.set(this.expanded());\n        }\n    }\n\n    onSelectionChange(uids: string[]) {\n        // Avoid infinite loop if you put unexisting uids as select will generate the same entries but with different reference\n        if (JSON.stringify(uids) === JSON.stringify(this.lastSelectedUids())) {\n            return;\n        }\n        this.lastSelectedUids.set(uids);\n        const selectedUids = this.collectSelectedUids(this.entries());\n        const uidToSelect = uids.filter(uid => selectedUids.every(selectedUid => selectedUid !== uid));\n        const uidToUnselect = selectedUids.filter(uid => uids.every(selectedUid => selectedUid !== uid));\n\n        if (!uidToSelect.length && !uidToUnselect.length) {\n            return;\n        }\n\n        let entries = this.entries();\n\n        if (this.multipleModeEnabled()) {\n            for (const uid of [...uidToSelect, ...uidToUnselect]) {\n                entries = NavSelectorMultiSelect.selectInMultipleMode(entries, uid);\n            }\n        } else {\n            entries = NavSelectorSingleSelect.select(entries, uids[0]);\n        }\n        this.entries.set(entries);\n    }\n\n    registerOnSelectedUidsChange(callback: (selectedUids: string[]) => void) {\n        this.selectedUidsChangeCallback = callback;\n    }\n\n    onArrowDown() {\n        this.entries.update(entries => NavSelectorAccessibility.focusNext(entries));\n    }\n\n    onArrowUp() {\n        this.entries.update(entries => NavSelectorAccessibility.focusPrevious(entries));\n    }\n\n    private collectSelectedUids(entries: InternalNavSelectorEntry[]): string[] {\n        return entries.flatMap(entry => {\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                if (entry.details.length) {\n                    return entry.details.flatMap(detail => (detail.selected ? [detail.uid] : []));\n                }\n                return entry.selected ? [entry.uid] : [];\n            } else if (isInternalNavSelectorEntryANode(entry)) {\n                return this.collectSelectedUids(entry.children);\n            }\n            return [];\n        });\n    }\n\n    updateLeafAction(leafActionProjection: ReadonlyArray<TemplateRef<unknown>>) {\n        this.leafActionProjection.set(leafActionProjection);\n    }\n\n    fold(entry: InternalNavSelectorEntry) {\n        this.entries.update(entries => NavSelectorFolding.fold(entries, entry.uid, !this.expanded()));\n    }\n\n    unfold(entry: InternalNavSelectorEntry) {\n        this.entries.update(entries => NavSelectorFolding.unfold(entries, entry.uid, !this.expanded()));\n    }\n\n    updateDetailsDisplayedLimit(detailsDisplayedLimit: number) {\n        this.entries.update(entries => NavSelectorViewMore.changeViewMoreDetailsDisplayedLimit(entries, detailsDisplayedLimit));\n    }\n\n    viewMore(leaf: InternalNavSelectorLeaf) {\n        this.entries.update(entries => NavSelectorViewMore.viewMore(entries, leaf.uid));\n    }\n\n    viewLess(leaf: InternalNavSelectorLeaf) {\n        this.entries.update(entries => NavSelectorViewMore.viewLess(entries, leaf.uid));\n    }\n}\n"]}

package/esm2022/nav-selector/public_api.mjs

@@ -0,0 +1,2 @@
+export * from './nav-selector.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvdWktY29tcG9uZW50cy9uYXYtc2VsZWN0b3Ivc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBUUEsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gICAgTmF2U2VsZWN0b3JDYXRlZ29yeSxcbiAgICBOYXZTZWxlY3Rvckdyb3VwLFxuICAgIE5hdlNlbGVjdG9yTGVhZixcbiAgICBOYXZTZWxlY3RvckxlYWZEZXRhaWxzLFxuICAgIE5hdlNlbGVjdG9yVHJhbnNsYXRlZFRleHRzLFxuICAgIE5vZGVBY2Nlc3NpYmlsaXR5LFxufSBmcm9tICcuL25hdi1zZWxlY3Rvcic7XG5leHBvcnQgKiBmcm9tICcuL25hdi1zZWxlY3Rvci5jb21wb25lbnQnO1xuIl19

package/esm2022/nav-selector/utils/leaf.utils.mjs

@@ -0,0 +1,10 @@
+export const isInternalNavSelectorEntryALeafFocusable = (leaf, { parentFolded, minified }) => {
+    if (parentFolded) {
+        return false;
+    }
+    if (minified) {
+        return !leaf.disabled && !leaf.displayTokenInvalid && !leaf.displayFeatureLocked;
+    }
+    return !leaf.disabled;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVhZi51dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvdWktY29tcG9uZW50cy9uYXYtc2VsZWN0b3Ivc3JjL3V0aWxzL2xlYWYudXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxDQUFDLE1BQU0sd0NBQXdDLEdBQUcsQ0FDcEQsSUFBNkIsRUFDN0IsRUFBRSxZQUFZLEVBQUUsUUFBUSxFQUFnRCxFQUNqRSxFQUFFO0lBQ1QsSUFBSSxZQUFZLEVBQUUsQ0FBQztRQUNmLE9BQU8sS0FBSyxDQUFDO0lBQ2pCLENBQUM7SUFDRCxJQUFJLFFBQVEsRUFBRSxDQUFDO1FBQ1gsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLElBQUksQ0FBQyxJQUFJLENBQUMsbUJBQW1CLElBQUksQ0FBQyxJQUFJLENBQUMsb0JBQW9CLENBQUM7SUFDckYsQ0FBQztJQUNELE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDO0FBQzFCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEludGVybmFsTmF2U2VsZWN0b3JMZWFmIH0gZnJvbSAnLi4vbmF2LXNlbGVjdG9yJztcblxuZXhwb3J0IGNvbnN0IGlzSW50ZXJuYWxOYXZTZWxlY3RvckVudHJ5QUxlYWZGb2N1c2FibGUgPSAoXG4gICAgbGVhZjogSW50ZXJuYWxOYXZTZWxlY3RvckxlYWYsXG4gICAgeyBwYXJlbnRGb2xkZWQsIG1pbmlmaWVkIH06IHsgcGFyZW50Rm9sZGVkOiBib29sZWFuOyBtaW5pZmllZDogYm9vbGVhbiB9XG4pOiBib29sZWFuID0+IHtcbiAgICBpZiAocGFyZW50Rm9sZGVkKSB7XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG4gICAgaWYgKG1pbmlmaWVkKSB7XG4gICAgICAgIHJldHVybiAhbGVhZi5kaXNhYmxlZCAmJiAhbGVhZi5kaXNwbGF5VG9rZW5JbnZhbGlkICYmICFsZWFmLmRpc3BsYXlGZWF0dXJlTG9ja2VkO1xuICAgIH1cbiAgICByZXR1cm4gIWxlYWYuZGlzYWJsZWQ7XG59O1xuIl19

package/esm2022/nav-selector/utils/nav-selector.accessibility.mjs

@@ -0,0 +1,171 @@
+import { isInternalNavSelectorEntryACategory, isInternalNavSelectorEntryAGroup, isInternalNavSelectorEntryALeaf, isInternalNavSelectorEntryALeafDetails, } from '../nav-selector';
+/**
+ * NavSelectorAccessibility is a utility class that provides methods to manage the accessibility and the focusability of nav selector entries.
+ */
+export 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) {
+        return entries.reduce((acc, entry) => {
+            if (!acc.length) {
+                return [{ ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.focusable ? 0 : -1 } }];
+            }
+            if (acc.every(({ focusable }) => !focusable)) {
+                return [...acc, { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.focusable ? 0 : -1 } }];
+            }
+            return [...acc, entry];
+        }, []);
+    }
+    /**
+     * 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(entries, uid) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {
+                return {
+                    ...this.focusAnEntry(entry, uid),
+                    children: NavSelectorAccessibility.focus(entry.children, uid),
+                };
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                return {
+                    ...this.focusAnEntry(entry, uid),
+                    details: entry.details.map(detail => this.focusAnEntry(detail, uid)),
+                };
+            }
+            return this.focusAnEntry(entry, uid);
+        });
+    }
+    /**
+     * 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, uid) {
+        return entries.map(entry => {
+            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {
+                return {
+                    ...this.unfocusAnEntry(entry, uid),
+                    children: NavSelectorAccessibility.unfocus(entry.children, uid),
+                };
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                return {
+                    ...this.unfocusAnEntry(entry, uid),
+                    details: entry.details.map(detail => this.unfocusAnEntry(detail, uid)),
+                };
+            }
+            return this.unfocusAnEntry(entry, uid);
+        });
+    }
+    /**
+     * 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(entries) {
+        const flattenEntries = this.flatten(entries);
+        const idxFocusedId = flattenEntries.findIndex(({ accessibility }) => accessibility.tabIndex === 0);
+        if (idxFocusedId === 0 || this.previousEntryIsFirstAndNotFocusable(flattenEntries, idxFocusedId)) {
+            return entries;
+        }
+        const focusedEntry = flattenEntries[idxFocusedId];
+        focusedEntry.accessibility.tabIndex = -1;
+        for (let i = idxFocusedId - 1; i >= 0; i--) {
+            const entry = flattenEntries[i];
+            if (entry.focusable) {
+                entry.accessibility.tabIndex = 0;
+                break;
+            }
+        }
+        return this.unflatten(flattenEntries);
+    }
+    /**
+     * 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(entries) {
+        const flattenEntries = this.flatten(entries);
+        const focusableFlattenEntries = flattenEntries.filter(entry => entry.focusable);
+        const idxFocusedId = focusableFlattenEntries.findIndex(({ accessibility }) => accessibility.tabIndex === 0);
+        if (focusableFlattenEntries.length - 1 <= idxFocusedId) {
+            return entries;
+        }
+        focusableFlattenEntries[idxFocusedId].accessibility.tabIndex = -1;
+        focusableFlattenEntries[idxFocusedId + 1].accessibility.tabIndex = 0;
+        return this.unflatten(flattenEntries);
+    }
+    static previousEntryIsFirstAndNotFocusable(flattenEntries, idxFocusedId) {
+        if (idxFocusedId - 1 === 0) {
+            const previous = flattenEntries[0];
+            return !previous.focusable;
+        }
+        return false;
+    }
+    static focusAnEntry(entry, uid) {
+        return { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.uid === uid ? 0 : -1 } };
+    }
+    static unfocusAnEntry(entry, uid) {
+        return { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.uid === uid ? -1 : entry.accessibility.tabIndex } };
+    }
+    /**
+     * 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
+     */
+    static flatten(entries) {
+        return entries.flatMap(entry => {
+            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {
+                return [{ ...entry, children: [] }, ...this.flatten(entry.children)];
+            }
+            if (isInternalNavSelectorEntryALeaf(entry)) {
+                return [{ ...entry, details: [] }, ...entry.details.map(detail => ({ ...detail }))];
+            }
+            return [{ ...entry }];
+        });
+    }
+    /**
+     * Unflatten the nav selector entries
+     * @param entries nav selector entries
+     */
+    static unflatten(entries) {
+        return entries.reduceRight((acc, entry) => {
+            if (!acc.length) {
+                return [entry];
+            }
+            if (entry.accessibility.ariaLevel < acc[0].accessibility.ariaLevel) {
+                if (isInternalNavSelectorEntryALeaf(entry)) {
+                    return [
+                        {
+                            ...entry,
+                            details: acc
+                                .filter(it => isInternalNavSelectorEntryALeafDetails(it))
+                                // Force destroying the reference to the original object else Angular will not detect the change
+                                .map(it => ({ ...it })),
+                        },
+                        ...acc.filter(it => !isInternalNavSelectorEntryALeafDetails(it)),
+                    ];
+                }
+                else if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {
+                    return [
+                        {
+                            ...entry,
+                            children: acc.filter(({ accessibility }) => accessibility.ariaLevel > entry.accessibility.ariaLevel),
+                        },
+                        ...acc.filter(({ accessibility }) => accessibility.ariaLevel <= entry.accessibility.ariaLevel),
+                    ];
+                }
+            }
+            return [entry, ...acc];
+        }, []);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-selector.accessibility.js","sourceRoot":"","sources":["../../../../../libs/ui-components/nav-selector/src/utils/nav-selector.accessibility.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    InternalNavSelectorEntry,\n    InternalNavSelectorGroup,\n    InternalNavSelectorLeaf,\n    InternalNavSelectorLeafDetails,\n    isInternalNavSelectorEntryACategory,\n    isInternalNavSelectorEntryAGroup,\n    isInternalNavSelectorEntryALeaf,\n    isInternalNavSelectorEntryALeafDetails,\n} from '../nav-selector';\n\n/**\n * NavSelectorAccessibility is a utility class that provides methods to manage the accessibility and the focusability of nav selector entries.\n */\nexport class NavSelectorAccessibility {\n    /**\n     * Set tabIndex to 0 for the first focusable entry and -1 for all other entries\n     * @param entries nav selector entries\n     */\n    static resetFocus(entries: InternalNavSelectorEntry[]): InternalNavSelectorEntry[] {\n        return entries.reduce((acc, entry) => {\n            if (!acc.length) {\n                return [{ ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.focusable ? 0 : -1 } }];\n            }\n\n            if (acc.every(({ focusable }) => !focusable)) {\n                return [...acc, { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.focusable ? 0 : -1 } }];\n            }\n\n            return [...acc, entry];\n        }, [] as InternalNavSelectorEntry[]);\n    }\n\n    /**\n     * Focus the given entry and set tabIndex to 0 for the given uid and -1 for all other entries\n     * @param entries nav selector entries\n     * @param uid the uid of the entry to focus\n     */\n    static focus<T extends InternalNavSelectorEntry>(entries: T[], uid: string): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {\n                return {\n                    ...this.focusAnEntry(entry, uid),\n                    children: NavSelectorAccessibility.focus(entry.children, uid),\n                } as InternalNavSelectorGroup;\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                return {\n                    ...this.focusAnEntry(entry, uid),\n                    details: entry.details.map(detail => this.focusAnEntry(detail, uid)),\n                } as InternalNavSelectorLeaf;\n            }\n            return this.focusAnEntry(entry, uid);\n        });\n    }\n\n    /**\n     * Unfocus the given entry and set tabIndex to -1 for the given uid and 0 for all other entries\n     * @param entries nav selector entries\n     * @param uid the uid of the entry to unfocus\n     */\n    static unfocus(entries: InternalNavSelectorEntry[], uid: string): InternalNavSelectorEntry[] {\n        return entries.map(entry => {\n            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {\n                return {\n                    ...this.unfocusAnEntry(entry, uid),\n                    children: NavSelectorAccessibility.unfocus(entry.children, uid),\n                } as InternalNavSelectorGroup;\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                return {\n                    ...this.unfocusAnEntry(entry, uid),\n                    details: entry.details.map(detail => this.unfocusAnEntry(detail, uid)),\n                } as InternalNavSelectorLeaf;\n            }\n            return this.unfocusAnEntry(entry, uid);\n        });\n    }\n\n    /**\n     * Focus the previous entry focusable and set tabIndex to 0 for the previous focusable entry and -1 for all other entries\n     *\n     * If not previous entries are focusable, entries will not be modified\n     *\n     * @param entries nav selector entries\n     */\n    static focusPrevious<T extends InternalNavSelectorEntry>(entries: T[]): InternalNavSelectorEntry[] {\n        const flattenEntries = this.flatten(entries);\n\n        const idxFocusedId = flattenEntries.findIndex(({ accessibility }) => accessibility.tabIndex === 0);\n\n        if (idxFocusedId === 0 || this.previousEntryIsFirstAndNotFocusable(flattenEntries, idxFocusedId)) {\n            return entries;\n        }\n\n        const focusedEntry = flattenEntries[idxFocusedId];\n        focusedEntry.accessibility.tabIndex = -1;\n\n        for (let i = idxFocusedId - 1; i >= 0; i--) {\n            const entry = flattenEntries[i];\n            if (entry.focusable) {\n                entry.accessibility.tabIndex = 0;\n                break;\n            }\n        }\n\n        return this.unflatten(flattenEntries);\n    }\n\n    /**\n     * Focus the next entry focusable and set tabIndex to 0 for the next focusable entry and -1 for all other entries\n     *\n     * If not next entries are focusable, entries will not be modified\n     *\n     * @param entries nav selector entries\n     */\n    static focusNext<T extends InternalNavSelectorEntry>(entries: T[]): InternalNavSelectorEntry[] {\n        const flattenEntries = this.flatten(entries);\n\n        const focusableFlattenEntries = flattenEntries.filter(entry => entry.focusable);\n\n        const idxFocusedId = focusableFlattenEntries.findIndex(({ accessibility }) => accessibility.tabIndex === 0);\n\n        if (focusableFlattenEntries.length - 1 <= idxFocusedId) {\n            return entries;\n        }\n\n        focusableFlattenEntries[idxFocusedId].accessibility.tabIndex = -1;\n\n        focusableFlattenEntries[idxFocusedId + 1].accessibility.tabIndex = 0;\n\n        return this.unflatten(flattenEntries);\n    }\n\n    private static previousEntryIsFirstAndNotFocusable(flattenEntries: InternalNavSelectorEntry[], idxFocusedId: number): boolean {\n        if (idxFocusedId - 1 === 0) {\n            const previous = flattenEntries[0];\n            return !previous.focusable;\n        }\n        return false;\n    }\n\n    private static focusAnEntry(entry: InternalNavSelectorEntry, uid: string): InternalNavSelectorEntry {\n        return { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.uid === uid ? 0 : -1 } };\n    }\n\n    private static unfocusAnEntry(entry: InternalNavSelectorEntry, uid: string): InternalNavSelectorEntry {\n        return { ...entry, accessibility: { ...entry.accessibility, tabIndex: entry.uid === uid ? -1 : entry.accessibility.tabIndex } };\n    }\n\n    /**\n     * 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\n     * @param entries nav selector entries\n     */\n    private static flatten(entries: InternalNavSelectorEntry[]): InternalNavSelectorEntry[] {\n        return entries.flatMap(entry => {\n            if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {\n                return [{ ...entry, children: [] }, ...this.flatten(entry.children)];\n            }\n            if (isInternalNavSelectorEntryALeaf(entry)) {\n                return [{ ...entry, details: [] }, ...entry.details.map(detail => ({ ...detail }))];\n            }\n            return [{ ...entry }];\n        });\n    }\n\n    /**\n     * Unflatten the nav selector entries\n     * @param entries nav selector entries\n     */\n    private static unflatten<T extends InternalNavSelectorEntry>(entries: T[]): InternalNavSelectorEntry[] {\n        return entries.reduceRight((acc, entry) => {\n            if (!acc.length) {\n                return [entry];\n            }\n            if (entry.accessibility.ariaLevel < acc[0].accessibility.ariaLevel) {\n                if (isInternalNavSelectorEntryALeaf(entry)) {\n                    return [\n                        {\n                            ...entry,\n                            details: acc\n                                .filter(it => isInternalNavSelectorEntryALeafDetails(it))\n                                // Force destroying the reference to the original object else Angular will not detect the change\n                                .map(it => ({ ...it })) as InternalNavSelectorLeafDetails[],\n                        },\n                        ...acc.filter(it => !isInternalNavSelectorEntryALeafDetails(it)),\n                    ];\n                } else if (isInternalNavSelectorEntryAGroup(entry) || isInternalNavSelectorEntryACategory(entry)) {\n                    return [\n                        {\n                            ...entry,\n                            children: acc.filter(\n                                ({ accessibility }) => accessibility.ariaLevel > entry.accessibility.ariaLevel\n                            ) as InternalNavSelectorLeaf[],\n                        },\n                        ...acc.filter(({ accessibility }) => accessibility.ariaLevel <= entry.accessibility.ariaLevel),\n                    ];\n                }\n            }\n            return [entry, ...acc];\n        }, [] as InternalNavSelectorEntry[]);\n    }\n}\n"]}