@verisoft/ui-core 21.0.15 → 21.0.17

package/fesm2022/verisoft-ui-core.mjs

@@ -1,5 +1,6 @@
 import * as i0 from '@angular/core';
-import { SimpleChange, InjectionToken, inject, Input, Component, Injectable, EventEmitter, Output, signal, ChangeDetectorRef, HostListener, Directive, Optional, Inject, TemplateRef, ContentChild, input, Pipe } from '@angular/core';
+import { InjectionToken, signal, input, output, inject, ElementRef, Injector, DestroyRef, isDevMode, Directive, effect, SimpleChange, Input, Component, Injectable, EventEmitter, Output, ChangeDetectorRef, HostListener, Optional, Inject, TemplateRef, ContentChild, Pipe } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
 import { startWith, switchMap, merge, map, debounceTime, BehaviorSubject, Subject, takeUntil, filter, tap, of, catchError } from 'rxjs';
 import * as i1 from '@angular/forms';
 import { FormControlName, FormControlDirective, NgModel, FormControl, ReactiveFormsModule } from '@angular/forms';
@@ -12,6 +13,876 @@ import { createResetStateAction, createInitNewDetailAction, createInitDetailActi
 import { v4 } from 'uuid';
 import { HttpClient } from '@angular/common/http';
 
+function assertNever(value) {
+    throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+function matchesKeyboardKey(event, keys) {
+    if (!keys.length) {
+        return false;
+    }
+    return keys.includes(event.key);
+}
+function suppressKeyboardEvent(event, preventDefault) {
+    if (!preventDefault) {
+        return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+}
+
+function filterEnabledItems(items) {
+    return items.filter((item) => !item.disabled);
+}
+function moveLinearIndex(currentIndex, delta, length, loop) {
+    if (length === 0) {
+        return -1;
+    }
+    if (currentIndex < 0) {
+        return delta > 0 ? 0 : length - 1;
+    }
+    const next = currentIndex + delta;
+    if (loop) {
+        if (next >= length) {
+            return 0;
+        }
+        if (next < 0) {
+            return length - 1;
+        }
+        return next;
+    }
+    return Math.max(0, Math.min(length - 1, next));
+}
+function resolveInitialActiveIndex(items, getItemId, initialActiveItemId) {
+    if (!items.length) {
+        return -1;
+    }
+    if (initialActiveItemId) {
+        const index = items.findIndex((item) => getItemId(item) === initialActiveItemId);
+        if (index >= 0) {
+            return index;
+        }
+    }
+    return 0;
+}
+function getRovingTabIndex(isActive) {
+    return isActive ? 0 : -1;
+}
+
+const DEFAULT_MENU_KEYBOARD_ACTIVE_ITEM_CLASS = 'menu-keyboard__item--active';
+const DEFAULT_MENU_KEYBOARD_NAVIGATION = {
+    enabled: true,
+    openKeys: ['ArrowDown', 'ArrowUp', 'Enter', ' '],
+    openToLastKeys: ['ArrowUp'],
+    nextKeys: ['ArrowDown'],
+    previousKeys: ['ArrowUp'],
+    firstKeys: ['Home'],
+    lastKeys: ['End'],
+    selectKeys: ['Enter', ' '],
+    closeKeys: ['Escape'],
+    dismissKeys: ['Tab'],
+    loop: true,
+    preventDefault: true,
+    activeItemClass: DEFAULT_MENU_KEYBOARD_ACTIVE_ITEM_CLASS,
+};
+
+const MENU_OPEN_ACTION_CHECKS = [
+    { keys: 'dismissKeys', action: 'dismiss' },
+    { keys: 'nextKeys', action: 'next' },
+    { keys: 'previousKeys', action: 'previous' },
+    { keys: 'firstKeys', action: 'first' },
+    { keys: 'lastKeys', action: 'last' },
+    { keys: 'selectKeys', action: 'activate' },
+    { keys: 'closeKeys', action: 'close' },
+];
+const MENU_TRIGGER_ACTION_CHECKS = [
+    { keys: 'openToLastKeys', action: 'openToLast' },
+    { keys: 'openKeys', action: 'open' },
+];
+const MENU_TRIGGER_ACTION_ORDER = [
+    'openToLast',
+    'open',
+];
+function resolveMenuTriggerAction(event, navigation) {
+    const matched = new Set();
+    for (const { keys, action } of MENU_TRIGGER_ACTION_CHECKS) {
+        if (matchesKeyboardKey(event, navigation[keys])) {
+            matched.add(action);
+        }
+    }
+    for (const action of MENU_TRIGGER_ACTION_ORDER) {
+        if (matched.has(action)) {
+            return action;
+        }
+    }
+    return null;
+}
+function resolveMenuKeyboardAction(event, navigation) {
+    for (const { keys, action } of MENU_OPEN_ACTION_CHECKS) {
+        if (matchesKeyboardKey(event, navigation[keys])) {
+            return action;
+        }
+    }
+    return null;
+}
+
+function resolveMenuKeyboardNavigation(input) {
+    if (input === undefined || input === false) {
+        return null;
+    }
+    const resolved = {
+        ...DEFAULT_MENU_KEYBOARD_NAVIGATION,
+        enabled: true,
+        ...(input === true ? {} : input),
+    };
+    if (!resolved.enabled) {
+        return null;
+    }
+    return resolved;
+}
+
+class MenuKeyboardController {
+    config;
+    focusedIndex = -1;
+    isOpen = false;
+    keyboardPresetFocus = false;
+    constructor(config) {
+        this.config = config;
+    }
+    get actionableItems() {
+        return filterEnabledItems(this.config.getItems());
+    }
+    isNavigationEnabled() {
+        return this.resolveNavigation() !== null;
+    }
+    getActiveItemClass() {
+        return (this.resolveNavigation()?.activeItemClass ??
+            DEFAULT_MENU_KEYBOARD_ACTIVE_ITEM_CLASS);
+    }
+    onTriggerKeydown(event) {
+        const navigation = this.resolveNavigation();
+        if (!navigation || this.isOpen) {
+            return;
+        }
+        const action = resolveMenuTriggerAction(event, navigation);
+        if (!action) {
+            return;
+        }
+        const items = this.actionableItems;
+        if (!items.length) {
+            return;
+        }
+        suppressKeyboardEvent(event, navigation.preventDefault);
+        this.applyTriggerAction(action, items, navigation);
+        this.keyboardPresetFocus = true;
+        this.config.onOpen();
+    }
+    onMenuKeydown(event) {
+        const navigation = this.resolveNavigation();
+        if (!navigation || !this.isOpen) {
+            return;
+        }
+        const items = this.actionableItems;
+        if (!items.length) {
+            return;
+        }
+        const action = resolveMenuKeyboardAction(event, navigation);
+        if (!action) {
+            return;
+        }
+        this.applyOpenMenuAction(action, event, navigation, items);
+    }
+    handleOpenChange(open) {
+        if (!open) {
+            this.isOpen = false;
+            this.focusedIndex = -1;
+            this.keyboardPresetFocus = false;
+            return;
+        }
+        const wasOpen = this.isOpen;
+        this.isOpen = true;
+        const navigation = this.resolveNavigation();
+        const items = this.actionableItems;
+        if (!items.length) {
+            this.isOpen = false;
+            this.focusedIndex = -1;
+            this.keyboardPresetFocus = false;
+            return;
+        }
+        if (!wasOpen) {
+            if (!this.keyboardPresetFocus) {
+                this.focusedIndex = navigation
+                    ? this.resolveInitialActiveIndex(navigation)
+                    : 0;
+            }
+            if (this.focusedIndex < 0 || this.focusedIndex >= items.length) {
+                this.focusedIndex = 0;
+            }
+        }
+        this.keyboardPresetFocus = false;
+    }
+    cancelPendingOpen() {
+        this.keyboardPresetFocus = false;
+        this.focusedIndex = -1;
+    }
+    close(restoreFocus) {
+        if (!this.isOpen) {
+            return;
+        }
+        this.config.onClose(restoreFocus);
+    }
+    setActiveItem(item) {
+        if (!this.isOpen) {
+            return;
+        }
+        const index = this.actionableItems.indexOf(item);
+        if (index >= 0) {
+            this.focusedIndex = index;
+        }
+    }
+    isItemFocused(item) {
+        if (!this.isOpen || this.focusedIndex < 0) {
+            return false;
+        }
+        const focusedItem = this.actionableItems[this.focusedIndex];
+        return focusedItem === item;
+    }
+    getItemTabIndex(item) {
+        return this.isItemFocused(item) ? 0 : -1;
+    }
+    applyTriggerAction(action, items, navigation) {
+        switch (action) {
+            case 'openToLast':
+                this.focusedIndex = items.length - 1;
+                return;
+            case 'open':
+                this.focusedIndex = this.resolveInitialActiveIndex(navigation);
+                return;
+            default:
+                assertNever(action);
+        }
+    }
+    applyOpenMenuAction(action, event, navigation, items) {
+        switch (action) {
+            case 'dismiss':
+                this.close(false);
+                return;
+            case 'next':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.focusedIndex = moveLinearIndex(this.focusedIndex, 1, items.length, navigation.loop);
+                return;
+            case 'previous':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.focusedIndex = moveLinearIndex(this.focusedIndex, -1, items.length, navigation.loop);
+                return;
+            case 'first':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.focusedIndex = 0;
+                return;
+            case 'last':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.focusedIndex = items.length - 1;
+                return;
+            case 'activate':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.activateFocused(items);
+                return;
+            case 'close':
+                suppressKeyboardEvent(event, navigation.preventDefault);
+                this.close(true);
+                return;
+            default:
+                assertNever(action);
+        }
+    }
+    resolveNavigation() {
+        const input = typeof this.config.keyboardNavigation === 'function'
+            ? this.config.keyboardNavigation()
+            : this.config.keyboardNavigation;
+        return resolveMenuKeyboardNavigation(input);
+    }
+    resolveInitialActiveIndex(navigation) {
+        return resolveInitialActiveIndex(this.actionableItems, (item) => this.getItemId(item), navigation.initialActiveItemId);
+    }
+    getItemId(item) {
+        if (this.config.getItemId) {
+            return this.config.getItemId(item);
+        }
+        return item.id;
+    }
+    activateFocused(items) {
+        const item = items[this.focusedIndex];
+        if (!item) {
+            return;
+        }
+        this.config.onSelect(item);
+        this.close(true);
+    }
+}
+
+const MENU_KEYBOARD_PORT = new InjectionToken('MENU_KEYBOARD_PORT');
+
+class MenuKeyboardFacade {
+    static nextListId = 0;
+    isOpen = signal(false, ...(ngDevMode ? [{ debugName: "isOpen" }] : []));
+    focusedIndex = signal(-1, ...(ngDevMode ? [{ debugName: "focusedIndex" }] : []));
+    focusRequestVersion = signal(0, ...(ngDevMode ? [{ debugName: "focusRequestVersion" }] : []));
+    activeItemClass = signal(DEFAULT_MENU_KEYBOARD_ACTIVE_ITEM_CLASS, ...(ngDevMode ? [{ debugName: "activeItemClass" }] : []));
+    listId = signal(`v-menu-kb-list-${MenuKeyboardFacade.nextListId++}`, ...(ngDevMode ? [{ debugName: "listId" }] : []));
+    actionableItems = signal([], ...(ngDevMode ? [{ debugName: "actionableItems" }] : []));
+    triggerElement = null;
+    listElement = null;
+    itemElements = new Map();
+    activeItemHandler = null;
+    triggerKeydownHandler = null;
+    focusItemHandler = null;
+    syncTriggerHandler = null;
+    syncItemHandler = null;
+    portProvider = null;
+    setPortProvider(provider) {
+        this.portProvider = provider;
+    }
+    setActiveItemHandler(handler) {
+        this.activeItemHandler = handler;
+    }
+    setTriggerKeydownHandler(handler) {
+        this.triggerKeydownHandler = handler;
+    }
+    setFocusItemHandler(handler) {
+        this.focusItemHandler = handler;
+    }
+    setSyncTriggerHandler(handler) {
+        this.syncTriggerHandler = handler;
+    }
+    setSyncItemHandler(handler) {
+        this.syncItemHandler = handler;
+    }
+    registerTrigger(element) {
+        this.triggerElement = element;
+    }
+    unregisterTrigger(element) {
+        if (this.triggerElement === element) {
+            this.triggerElement = null;
+        }
+    }
+    registerList(element) {
+        this.listElement = element;
+    }
+    unregisterList(element) {
+        if (this.listElement === element) {
+            this.listElement = null;
+        }
+    }
+    registerItem(item, element) {
+        this.itemElements.set(item, element);
+    }
+    unregisterItem(item, element) {
+        const registered = this.itemElements.get(item);
+        if (registered === element) {
+            this.itemElements.delete(item);
+        }
+    }
+    unregisterItemElement(element) {
+        for (const [item, registered] of this.itemElements.entries()) {
+            if (registered === element) {
+                this.itemElements.delete(item);
+            }
+        }
+    }
+    getTriggerElement() {
+        return this.triggerElement;
+    }
+    getListElement() {
+        return this.listElement;
+    }
+    publish(controller, items) {
+        const wasOpen = this.isOpen();
+        const previousFocusedIndex = this.focusedIndex();
+        const nextFocusedIndex = controller.focusedIndex;
+        this.isOpen.set(controller.isOpen);
+        this.focusedIndex.set(nextFocusedIndex);
+        this.activeItemClass.set(controller.getActiveItemClass());
+        this.actionableItems.set(filterEnabledItems(items));
+        if (controller.isOpen &&
+            wasOpen &&
+            nextFocusedIndex >= 0 &&
+            previousFocusedIndex !== nextFocusedIndex) {
+            this.focusRequestVersion.update((value) => value + 1);
+        }
+    }
+    isItemActive(item) {
+        if (!this.isOpen() || this.focusedIndex() < 0) {
+            return false;
+        }
+        const items = this.actionableItems();
+        return items[this.focusedIndex()] === item;
+    }
+    getItemTabIndex(item) {
+        return this.isItemActive(item) ? 0 : -1;
+    }
+    requestActiveItem(item) {
+        this.activeItemHandler?.(item);
+    }
+    requestTriggerKeydown(event) {
+        this.triggerKeydownHandler?.(event);
+    }
+    getActiveItemElement() {
+        const items = this.actionableItems();
+        const index = this.focusedIndex();
+        if (!this.isOpen() || index < 0 || index >= items.length) {
+            return null;
+        }
+        return this.itemElements.get(items[index]) ?? null;
+    }
+    requestItemFocus(host, a11y) {
+        if (this.focusItemHandler) {
+            this.focusItemHandler(host, a11y);
+            return;
+        }
+        host.focus({ preventScroll: true });
+    }
+    requestTriggerAccessibilitySync(host, a11y) {
+        this.syncTriggerHandler?.(host, a11y);
+    }
+    requestItemAccessibilitySync(host, a11y) {
+        this.syncItemHandler?.(host, a11y);
+    }
+    resolveItemFromTarget(target) {
+        for (const [item, element] of this.itemElements.entries()) {
+            if (element.contains(target)) {
+                return item;
+            }
+        }
+        return null;
+    }
+    getPort() {
+        return this.portProvider?.() ?? null;
+    }
+}
+
+const MENU_KEYBOARD = new InjectionToken('MENU_KEYBOARD');
+
+class MenuKeyboardDirective {
+    menuKeyboardItems = input([], ...(ngDevMode ? [{ debugName: "menuKeyboardItems" }] : []));
+    menuKeyboardNavigation = input(undefined, ...(ngDevMode ? [{ debugName: "menuKeyboardNavigation" }] : []));
+    menuKeyboardEnableWhenUnset = input(false, ...(ngDevMode ? [{ debugName: "menuKeyboardEnableWhenUnset" }] : []));
+    menuKeyboardDefaults = input({}, ...(ngDevMode ? [{ debugName: "menuKeyboardDefaults" }] : []));
+    menuKeyboardItemId = input((item) => item.id, ...(ngDevMode ? [{ debugName: "menuKeyboardItemId" }] : []));
+    menuKeyboardSelect = output();
+    facade = inject((MenuKeyboardFacade));
+    isOpen = this.facade.isOpen;
+    focusedIndex = this.facade.focusedIndex;
+    activeItemClass = this.facade.activeItemClass;
+    listId = this.facade.listId;
+    elementRef = inject((ElementRef));
+    document = inject(DOCUMENT);
+    injector = inject(Injector);
+    destroyRef = inject(DestroyRef);
+    onDocumentKeydown = (event) => this.handleDocumentKeydown(event);
+    portOperationState = 'idle';
+    pendingPortIntent = null;
+    controller = new MenuKeyboardController({
+        getItems: () => this.menuKeyboardItems(),
+        getItemId: (item) => this.menuKeyboardItemId()(item),
+        keyboardNavigation: () => this.resolveNavigation(),
+        onSelect: (item) => this.menuKeyboardSelect.emit(item),
+        onOpen: () => {
+            this.schedulePortIntent({ type: 'open' });
+        },
+        onClose: (restoreFocus) => {
+            this.schedulePortIntent({ type: 'close', restoreFocus });
+        },
+    });
+    constructor() {
+        this.facade.setPortProvider(() => this.getPort());
+        this.facade.setActiveItemHandler((item) => {
+            this.controller.setActiveItem(item);
+            this.publishState();
+        });
+        this.facade.setTriggerKeydownHandler((event) => {
+            this.handleTriggerKeydown(event);
+        });
+        this.facade.setFocusItemHandler((host, a11y) => {
+            this.focusItemHost(host, a11y);
+        });
+        this.facade.setSyncTriggerHandler((host, a11y) => {
+            this.applyTriggerAccessibility(host, a11y);
+        });
+        this.facade.setSyncItemHandler((host, a11y) => {
+            this.applyItemAccessibility(host, a11y);
+        });
+        this.destroyRef.onDestroy(() => {
+            this.facade.setTriggerKeydownHandler(() => undefined);
+            this.facade.setFocusItemHandler(() => undefined);
+            this.facade.setSyncTriggerHandler(() => undefined);
+            this.facade.setSyncItemHandler(() => undefined);
+            this.facade.setPortProvider(() => null);
+            this.unbindDocumentKeydown();
+        });
+    }
+    handleOpenChange(open) {
+        this.controller.handleOpenChange(open);
+        if (open && !this.controller.isOpen) {
+            void this.schedulePortIntent({ type: 'close', restoreFocus: false });
+        }
+        if (this.controller.isOpen) {
+            this.bindDocumentKeydown();
+        }
+        else {
+            this.unbindDocumentKeydown();
+        }
+        this.publishState();
+    }
+    close(restoreFocus = false) {
+        this.schedulePortIntent({ type: 'close', restoreFocus });
+    }
+    focusTrigger() {
+        const trigger = this.facade.getTriggerElement();
+        if (!trigger) {
+            return;
+        }
+        const a11y = {
+            ariaHaspopup: 'menu',
+            ariaExpanded: String(this.facade.isOpen()),
+            ariaControls: this.facade.listId(),
+        };
+        const port = this.getPort();
+        if (port?.focusTrigger) {
+            port.focusTrigger(trigger, a11y);
+            return;
+        }
+        trigger.focus({ preventScroll: true });
+    }
+    focusActiveItem() {
+        if (!this.controller.isOpen || this.controller.focusedIndex < 0) {
+            return;
+        }
+        const items = this.controller.actionableItems;
+        const item = items[this.controller.focusedIndex];
+        const host = this.facade.getActiveItemElement();
+        if (!item || !host) {
+            return;
+        }
+        this.focusItemHost(host, this.buildItemFocusA11y(item));
+    }
+    getTriggerElement() {
+        return this.facade.getTriggerElement() ?? undefined;
+    }
+    getListElement() {
+        return this.facade.getListElement() ?? undefined;
+    }
+    isItemActive(item) {
+        return this.facade.isItemActive(item);
+    }
+    getItemTabIndex(item) {
+        return this.facade.getItemTabIndex(item);
+    }
+    hasActionableItems() {
+        return this.controller.actionableItems.length > 0;
+    }
+    handleTriggerKeydown(event) {
+        if (this.controller.isOpen || !this.controller.isNavigationEnabled()) {
+            return;
+        }
+        this.controller.onTriggerKeydown(event);
+        this.publishState();
+    }
+    handleDocumentKeydown(event) {
+        if (!this.controller.isOpen || !this.shouldHandleDocumentKeydown(event)) {
+            return;
+        }
+        this.controller.onMenuKeydown(event);
+        this.publishState();
+    }
+    shouldHandleDocumentKeydown(event) {
+        const host = this.elementRef.nativeElement;
+        const listElement = this.facade.getListElement();
+        const path = event.composedPath();
+        if (path.includes(host)) {
+            return true;
+        }
+        return !!(listElement && path.includes(listElement));
+    }
+    bindDocumentKeydown() {
+        this.document.removeEventListener('keydown', this.onDocumentKeydown, true);
+        this.document.addEventListener('keydown', this.onDocumentKeydown, true);
+    }
+    unbindDocumentKeydown() {
+        this.document.removeEventListener('keydown', this.onDocumentKeydown, true);
+    }
+    focusItemHost(host, a11y) {
+        const resolvedA11y = a11y ??
+            (() => {
+                const item = this.facade.resolveItemFromTarget(host);
+                return item ? this.buildItemFocusA11y(item) : undefined;
+            })();
+        const port = this.getPort();
+        if (port?.focusItem) {
+            port.focusItem(host, resolvedA11y);
+            return;
+        }
+        host.focus({ preventScroll: true });
+    }
+    applyTriggerAccessibility(host, a11y) {
+        this.getPort()?.applyTriggerAccessibility?.(host, a11y);
+    }
+    applyItemAccessibility(host, a11y) {
+        this.getPort()?.applyItemAccessibility?.(host, a11y);
+    }
+    buildItemFocusA11y(item) {
+        return {
+            role: 'menuitem',
+            tabIndex: this.getItemTabIndex(item),
+            ariaDisabled: String(item.disabled ?? false),
+        };
+    }
+    publishState() {
+        this.facade.publish(this.controller, this.menuKeyboardItems());
+    }
+    schedulePortIntent(intent) {
+        if (this.portOperationState === 'idle') {
+            void this.executePortIntent(intent);
+            return;
+        }
+        this.pendingPortIntent = intent;
+    }
+    async executePortIntent(intent) {
+        switch (intent.type) {
+            case 'open':
+                await this.openViaPort();
+                return;
+            case 'close':
+                await this.closeViaPort(intent.restoreFocus);
+                return;
+            default:
+                assertNever(intent);
+        }
+    }
+    async drainPendingPortIntent() {
+        const intent = this.pendingPortIntent;
+        this.pendingPortIntent = null;
+        if (!intent) {
+            return;
+        }
+        await this.executePortIntent(intent);
+    }
+    async openViaPort() {
+        const port = this.getPort();
+        if (!port) {
+            this.controller.cancelPendingOpen();
+            this.publishState();
+            return;
+        }
+        this.portOperationState = 'opening';
+        try {
+            const opened = await port.open();
+            if (opened === false) {
+                this.controller.cancelPendingOpen();
+            }
+        }
+        catch (error) {
+            this.controller.cancelPendingOpen();
+            this.reportPortError('open', error);
+        }
+        finally {
+            this.portOperationState = 'idle';
+            this.publishState();
+            await this.drainPendingPortIntent();
+        }
+    }
+    async closeViaPort(restoreFocus) {
+        const port = this.getPort();
+        if (!port) {
+            return;
+        }
+        this.portOperationState = 'closing';
+        try {
+            await port.close(restoreFocus);
+        }
+        catch (error) {
+            this.reportPortError('close', error);
+        }
+        finally {
+            this.portOperationState = 'idle';
+            this.publishState();
+            await this.drainPendingPortIntent();
+        }
+    }
+    reportPortError(operation, error) {
+        if (isDevMode()) {
+            console.warn(`[vMenuKeyboard] Port ${operation} failed.`, error);
+        }
+    }
+    getPort() {
+        return this.injector.get(MENU_KEYBOARD_PORT, null, { optional: true });
+    }
+    resolveNavigation() {
+        const input = this.menuKeyboardNavigation();
+        const defaults = this.menuKeyboardDefaults();
+        if (input === false) {
+            return false;
+        }
+        if (input === undefined) {
+            if (!this.menuKeyboardEnableWhenUnset()) {
+                return undefined;
+            }
+            return Object.keys(defaults).length ? defaults : true;
+        }
+        if (input === true) {
+            return Object.keys(defaults).length ? defaults : true;
+        }
+        return {
+            ...defaults,
+            ...input,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.3", type: MenuKeyboardDirective, isStandalone: true, selector: "[vMenuKeyboard]", inputs: { menuKeyboardItems: { classPropertyName: "menuKeyboardItems", publicName: "menuKeyboardItems", isSignal: true, isRequired: false, transformFunction: null }, menuKeyboardNavigation: { classPropertyName: "menuKeyboardNavigation", publicName: "menuKeyboardNavigation", isSignal: true, isRequired: false, transformFunction: null }, menuKeyboardEnableWhenUnset: { classPropertyName: "menuKeyboardEnableWhenUnset", publicName: "menuKeyboardEnableWhenUnset", isSignal: true, isRequired: false, transformFunction: null }, menuKeyboardDefaults: { classPropertyName: "menuKeyboardDefaults", publicName: "menuKeyboardDefaults", isSignal: true, isRequired: false, transformFunction: null }, menuKeyboardItemId: { classPropertyName: "menuKeyboardItemId", publicName: "menuKeyboardItemId", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { menuKeyboardSelect: "menuKeyboardSelect" }, providers: [
+            MenuKeyboardFacade,
+            { provide: MENU_KEYBOARD, useExisting: MenuKeyboardFacade },
+        ], exportAs: ["menuKeyboard"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vMenuKeyboard]',
+                    exportAs: 'menuKeyboard',
+                    providers: [
+                        MenuKeyboardFacade,
+                        { provide: MENU_KEYBOARD, useExisting: MenuKeyboardFacade },
+                    ],
+                }]
+        }], ctorParameters: () => [], propDecorators: { menuKeyboardItems: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardItems", required: false }] }], menuKeyboardNavigation: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardNavigation", required: false }] }], menuKeyboardEnableWhenUnset: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardEnableWhenUnset", required: false }] }], menuKeyboardDefaults: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardDefaults", required: false }] }], menuKeyboardItemId: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardItemId", required: false }] }], menuKeyboardSelect: [{ type: i0.Output, args: ["menuKeyboardSelect"] }] } });
+
+class MenuKeyboardTriggerDirective {
+    facade = inject(MENU_KEYBOARD);
+    elementRef = inject((ElementRef));
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        const element = this.elementRef.nativeElement;
+        this.facade.registerTrigger(element);
+        effect(() => {
+            this.facade.requestTriggerAccessibilitySync(element, {
+                ariaHaspopup: 'menu',
+                ariaExpanded: String(this.facade.isOpen()),
+                ariaControls: this.facade.listId(),
+            });
+        });
+        this.destroyRef.onDestroy(() => {
+            this.facade.unregisterTrigger(element);
+        });
+    }
+    onKeydown(event) {
+        this.facade.requestTriggerKeydown(event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardTriggerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.1.3", type: MenuKeyboardTriggerDirective, isStandalone: true, selector: "[vMenuKeyboardTrigger]", host: { attributes: { "aria-haspopup": "menu" }, listeners: { "keydown": "onKeydown($event)" }, properties: { "attr.aria-expanded": "facade.isOpen()", "attr.aria-controls": "facade.listId()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vMenuKeyboardTrigger]',
+                    host: {
+                        'aria-haspopup': 'menu',
+                        '[attr.aria-expanded]': 'facade.isOpen()',
+                        '[attr.aria-controls]': 'facade.listId()',
+                        '(keydown)': 'onKeydown($event)',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+
+class MenuKeyboardListDirective {
+    facade = inject(MENU_KEYBOARD);
+    elementRef = inject((ElementRef));
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        const element = this.elementRef.nativeElement;
+        this.facade.registerList(element);
+        this.destroyRef.onDestroy(() => {
+            this.facade.unregisterList(element);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.1.3", type: MenuKeyboardListDirective, isStandalone: true, selector: "[vMenuKeyboardList]", host: { attributes: { "role": "menu", "tabindex": "-1" }, properties: { "id": "facade.listId()" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vMenuKeyboardList]',
+                    host: {
+                        role: 'menu',
+                        tabindex: '-1',
+                        '[id]': 'facade.listId()',
+                    },
+                }]
+        }], ctorParameters: () => [] });
+
+class MenuKeyboardItemDirective {
+    item = input.required({ ...(ngDevMode ? { debugName: "item" } : {}), alias: 'menuKeyboardItem' });
+    facade = inject(MENU_KEYBOARD);
+    elementRef = inject((ElementRef));
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        const element = this.elementRef.nativeElement;
+        effect((onCleanup) => {
+            const menuItem = this.item();
+            this.facade.registerItem(menuItem, element);
+            onCleanup(() => {
+                this.facade.unregisterItem(menuItem, element);
+            });
+        });
+        effect(() => {
+            const activeClass = this.facade.activeItemClass();
+            const isActive = this.facade.isItemActive(this.item());
+            element.classList.toggle(activeClass, isActive);
+        });
+        effect(() => {
+            this.facade.isOpen();
+            this.facade.focusedIndex();
+            this.facade.requestItemAccessibilitySync(element, {
+                role: 'menuitem',
+                tabIndex: this.facade.getItemTabIndex(this.item()),
+                ariaDisabled: String(this.item().disabled ?? false),
+            });
+        });
+        effect(() => {
+            this.facade.focusRequestVersion();
+            if (!this.facade.isOpen() || !this.facade.isItemActive(this.item())) {
+                return;
+            }
+            this.facade.requestItemFocus(element, {
+                role: 'menuitem',
+                tabIndex: this.facade.getItemTabIndex(this.item()),
+                ariaDisabled: String(this.item().disabled ?? false),
+            });
+        });
+        this.destroyRef.onDestroy(() => {
+            this.facade.unregisterItemElement(element);
+        });
+    }
+    onMouseEnter() {
+        const menuItem = this.item();
+        if (menuItem.disabled) {
+            return;
+        }
+        this.facade.requestActiveItem(menuItem);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardItemDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.1.3", type: MenuKeyboardItemDirective, isStandalone: true, selector: "[vMenuKeyboardItem]", inputs: { item: { classPropertyName: "item", publicName: "menuKeyboardItem", isSignal: true, isRequired: true, transformFunction: null } }, host: { attributes: { "role": "menuitem" }, listeners: { "mouseenter": "onMouseEnter()" }, properties: { "attr.tabindex": "facade.getItemTabIndex(item())", "attr.aria-disabled": "item().disabled ?? false" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.3", ngImport: i0, type: MenuKeyboardItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[vMenuKeyboardItem]',
+                    host: {
+                        role: 'menuitem',
+                        '[attr.tabindex]': 'facade.getItemTabIndex(item())',
+                        '[attr.aria-disabled]': 'item().disabled ?? false',
+                        '(mouseenter)': 'onMouseEnter()',
+                    },
+                }]
+        }], ctorParameters: () => [], propDecorators: { item: [{ type: i0.Input, args: [{ isSignal: true, alias: "menuKeyboardItem", required: true }] }] } });
+
 function setComponentProperties(component, value, firstChange = false) {
     if (!value || !component) {
         return;
@@ -2185,5 +3056,5 @@ class Format {
  * Generated bundle index. Do not edit.
  */
 
-export { ACTION_BUTTON_GROUP_COMPONENT_TOKEN, BREADCRUMB_COMPONENT_TOKEN, BUTTON_COMPONENT_TOKEN, BaseFormDirective, BaseFormInputComponent, BaseInputControls, BreadcrumbCoreComponent, BreadcrumbService, ButtonShortCutDirective, CALENDAR_COMPONENT_TOKEN, CHECKBOX_COMPONENT_TOKEN, CONFIRM_DIALOG_COMPONENT_TOKEN, ColumnConfiguration, ColumnModel, ColumnVisibility, ControlSeverity, DEFAULT_DEBOUNCE_TIME, DEFAULT_PAGINATION, DROPDOWN_BUTTON_COMPONENT_TOKEN, DROPDOWN_COMPONENT_TOKEN, DatasourceDirective, DetailStoreDirective, DialogService, EnumToListPipe, ErrorCodesFns, ErrorPipe, FEATURE_LIST_COLUMN_PROVIDER, FEATURE_LIST_COMPONENT_TOKEN, FEATURE_LIST_PAGE_CONFIG_PROPERTY, FILTER_COMPONENT_TOKEN, FORM_FIELD_COMPONENT_TOKEN, FeatureListColumnDirective, FeatureListFilterFieldDirective, FeatureListFilterPipe, FieldAlign, FieldSize, FieldType, FilterFieldDirective, Format, GENERIC_FIELD_COMPONENT_TOKEN, GenericFieldType, GovButtonType, GovControlSeverity, HEADER_COMPONENT_TOKEN, ICONS_COMPONENT_TOKEN, INPUT_GROUP_COMPONENT_TOKEN, IconPosition, IconsComponent, KeyOrFunctionPipe, LOADER_COMPONENT_TOKEN, LOGO_ROUTER_ROUTE, LayoutType, LinkRenderer, MAX_COLUMN_CHAR_COUNT, MENU_TOKEN, MULTISELECT_COMPONENT_TOKEN, MenuServiceDirective, NUMBER_INPUT_COMPONENT_TOKEN, PAGE_HEADER_COMPONENT_TOKEN, PASSWORD_COMPONENT_TOKEN, PageHeaderCoreComponent, PageHeaderService, PasswordStrength, Position, PreventUnsavedChangesDirective, RADIOBUTTON_COMPONENT_TOKEN, Renderer, RowModel, SECTION_COMPONENT_TOKEN, SETTINGS_MENU, SIDE_MENU_COMPONENT_TOKEN, SIDE_MENU_STATE_TOKEN, SLIDER_COMPONENT_TOKEN, SNACKBAR_COMPONENT_TOKEN, STEPPER_COMPONENT_TOKEN, SWITCH_COMPONENT_TOKEN, ScreenSizeService, SideMenuProviderService, SideMenuService, SlotPosition, TABLE_COLUMN_PROVIDER, TABLE_COMPONENT_TOKEN, TABLE_FILTER_COMPONENT_TOKEN, TAB_VIEW_COMPONENT_TOKEN, TAG_COMPONENT_TOKEN, TEXTAREA_COMPONENT_TOKEN, TEXTFIELD_COMPONENT_TOKEN, TOOLTIP_COMPONENT_TOKEN, TableBuilder, TableButtonSeverity, TableColumnDirective, TableDatasourceDirective, TableFilterDirective, TableSelectionMode, TableService, UnsubscribeComponent, WarningCodesFns, WarningPipe, downloadFile, downloadText, getFilledControlCount, getFirstError, getFirstErrorFromControl, isFilterEmpty, isFormStateEqual, queryListChanged, routerRenderer, setComponentProperties, setDataToArray };
+export { ACTION_BUTTON_GROUP_COMPONENT_TOKEN, BREADCRUMB_COMPONENT_TOKEN, BUTTON_COMPONENT_TOKEN, BaseFormDirective, BaseFormInputComponent, BaseInputControls, BreadcrumbCoreComponent, BreadcrumbService, ButtonShortCutDirective, CALENDAR_COMPONENT_TOKEN, CHECKBOX_COMPONENT_TOKEN, CONFIRM_DIALOG_COMPONENT_TOKEN, ColumnConfiguration, ColumnModel, ColumnVisibility, ControlSeverity, DEFAULT_DEBOUNCE_TIME, DEFAULT_MENU_KEYBOARD_ACTIVE_ITEM_CLASS, DEFAULT_MENU_KEYBOARD_NAVIGATION, DEFAULT_PAGINATION, DROPDOWN_BUTTON_COMPONENT_TOKEN, DROPDOWN_COMPONENT_TOKEN, DatasourceDirective, DetailStoreDirective, DialogService, EnumToListPipe, ErrorCodesFns, ErrorPipe, FEATURE_LIST_COLUMN_PROVIDER, FEATURE_LIST_COMPONENT_TOKEN, FEATURE_LIST_PAGE_CONFIG_PROPERTY, FILTER_COMPONENT_TOKEN, FORM_FIELD_COMPONENT_TOKEN, FeatureListColumnDirective, FeatureListFilterFieldDirective, FeatureListFilterPipe, FieldAlign, FieldSize, FieldType, FilterFieldDirective, Format, GENERIC_FIELD_COMPONENT_TOKEN, GenericFieldType, GovButtonType, GovControlSeverity, HEADER_COMPONENT_TOKEN, ICONS_COMPONENT_TOKEN, INPUT_GROUP_COMPONENT_TOKEN, IconPosition, IconsComponent, KeyOrFunctionPipe, LOADER_COMPONENT_TOKEN, LOGO_ROUTER_ROUTE, LayoutType, LinkRenderer, MAX_COLUMN_CHAR_COUNT, MENU_KEYBOARD, MENU_KEYBOARD_PORT, MENU_TOKEN, MULTISELECT_COMPONENT_TOKEN, MenuKeyboardController, MenuKeyboardDirective, MenuKeyboardFacade, MenuKeyboardItemDirective, MenuKeyboardListDirective, MenuKeyboardTriggerDirective, MenuServiceDirective, NUMBER_INPUT_COMPONENT_TOKEN, PAGE_HEADER_COMPONENT_TOKEN, PASSWORD_COMPONENT_TOKEN, PageHeaderCoreComponent, PageHeaderService, PasswordStrength, Position, PreventUnsavedChangesDirective, RADIOBUTTON_COMPONENT_TOKEN, Renderer, RowModel, SECTION_COMPONENT_TOKEN, SETTINGS_MENU, SIDE_MENU_COMPONENT_TOKEN, SIDE_MENU_STATE_TOKEN, SLIDER_COMPONENT_TOKEN, SNACKBAR_COMPONENT_TOKEN, STEPPER_COMPONENT_TOKEN, SWITCH_COMPONENT_TOKEN, ScreenSizeService, SideMenuProviderService, SideMenuService, SlotPosition, TABLE_COLUMN_PROVIDER, TABLE_COMPONENT_TOKEN, TABLE_FILTER_COMPONENT_TOKEN, TAB_VIEW_COMPONENT_TOKEN, TAG_COMPONENT_TOKEN, TEXTAREA_COMPONENT_TOKEN, TEXTFIELD_COMPONENT_TOKEN, TOOLTIP_COMPONENT_TOKEN, TableBuilder, TableButtonSeverity, TableColumnDirective, TableDatasourceDirective, TableFilterDirective, TableSelectionMode, TableService, UnsubscribeComponent, WarningCodesFns, WarningPipe, assertNever, downloadFile, downloadText, filterEnabledItems, getFilledControlCount, getFirstError, getFirstErrorFromControl, getRovingTabIndex, isFilterEmpty, isFormStateEqual, matchesKeyboardKey, moveLinearIndex, queryListChanged, resolveInitialActiveIndex, resolveMenuKeyboardAction, resolveMenuKeyboardNavigation, resolveMenuTriggerAction, routerRenderer, setComponentProperties, setDataToArray, suppressKeyboardEvent };
 //# sourceMappingURL=verisoft-ui-core.mjs.map