primevue 3.15.0 → 3.16.2

package/listbox/listbox.js

@@ -9,7 +9,7 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
 
     var script = {
         name: 'Listbox',
-        emits: ['update:modelValue', 'change', 'filter'],
+        emits: ['update:modelValue', 'change', 'focus', 'blur', 'filter'],
         props: {
             modelValue: null,
             options: Array,
@@ -34,6 +34,27 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
                 type: Array,
                 default: null
             },
+            filterInputProps: null,
+            virtualScrollerOptions: {
+                type: Object,
+                default: null
+            },
+            autoOptionFocus: {
+                type: Boolean,
+                default: true
+            },
+            filterMessage: {
+                type: String,
+                default: null
+            },
+            selectionMessage: {
+                type: String,
+                default: null
+            },
+            emptySelectionMessage: {
+                type: String,
+                default: null
+            },
             emptyFilterMessage: {
                 type: String,
                 default: null
@@ -42,17 +63,44 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
                 type: String,
                 default: null
             },
-            virtualScrollerOptions: {
-                type: Object,
+            tabindex: {
+                type: Number,
+                default: 0
+            },
+            'aria-label': {
+                type: String,
+                default: null
+            },
+            'aria-labelledby': {
+                type: String,
                 default: null
             }
         },
-        optionTouched: false,
+        list: null,
         virtualScroller: null,
+        optionTouched: false,
+        startRangeIndex: -1,
+        searchTimeout: null,
+        searchValue: '',
+        selectOnFocus: false,
+        focusOnHover: false,
         data() {
             return {
-                filterValue: null
-            };
+                id: utils.UniqueComponentId(),
+                filterValue: null,
+                focused: false,
+                focusedOptionIndex: -1
+            }
+        },
+        watch: {
+            options() {
+                this.autoUpdateModel();
+            }
+        },
+        mounted() {
+            this.id = this.$attrs.id || this.id;
+
+            this.autoUpdateModel();
         },
         methods: {
             getOptionIndex(index, fn) {
@@ -64,14 +112,14 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
             getOptionValue(option) {
                 return this.optionValue ? utils.ObjectUtils.resolveFieldData(option, this.optionValue) : option;
             },
-            getOptionRenderKey(option) {
-                return this.dataKey ? utils.ObjectUtils.resolveFieldData(option, this.dataKey) : this.getOptionLabel(option);
+            getOptionRenderKey(option, index) {
+                return (this.dataKey ? utils.ObjectUtils.resolveFieldData(option, this.dataKey) : this.getOptionLabel(option)) + '_' + index;
             },
             isOptionDisabled(option) {
                 return this.optionDisabled ? utils.ObjectUtils.resolveFieldData(option, this.optionDisabled) : false;
             },
-            getOptionGroupRenderKey(optionGroup) {
-                return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel);
+            isOptionGroup(option) {
+                return this.optionGroupLabel && option.optionGroup && option.group;
             },
             getOptionGroupLabel(optionGroup) {
                 return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupLabel);
@@ -79,17 +127,116 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
             getOptionGroupChildren(optionGroup) {
                 return utils.ObjectUtils.resolveFieldData(optionGroup, this.optionGroupChildren);
             },
-            onOptionSelect(event, option) {
+            getAriaPosInset(index) {
+                return (this.optionGroupLabel ? index - this.visibleOptions.slice(0, index).filter(option => this.isOptionGroup(option)).length : index) + 1;
+            },
+            onFirstHiddenFocus() {
+                this.list.focus();
+
+                const firstFocusableEl = utils.DomHandler.getFirstFocusableElement(this.$el, ':not(.p-hidden-focusable)');
+                this.$refs.lastHiddenFocusableElement.tabIndex = utils.ObjectUtils.isEmpty(firstFocusableEl) ? -1 : undefined;
+                this.$refs.firstHiddenFocusableElement.tabIndex = -1;
+            },
+            onLastHiddenFocus(event) {
+                const relatedTarget = event.relatedTarget;
+
+                if (relatedTarget === this.list) {
+                    const firstFocusableEl = utils.DomHandler.getFirstFocusableElement(this.$el, ':not(.p-hidden-focusable)');
+                    firstFocusableEl && firstFocusableEl.focus();
+                    this.$refs.firstHiddenFocusableElement.tabIndex = undefined;
+                }
+                else {
+                    this.$refs.firstHiddenFocusableElement.focus();
+                }
+
+                this.$refs.lastHiddenFocusableElement.tabIndex = -1;
+            },
+            onFocusout(event) {
+                if (!this.$el.contains(event.relatedTarget) && this.$refs.lastHiddenFocusableElement && this.$refs.firstHiddenFocusableElement) {
+                    this.$refs.lastHiddenFocusableElement.tabIndex = this.$refs.firstHiddenFocusableElement.tabIndex = undefined;
+                }
+            },
+            onListFocus(event) {
+                this.focused = true;
+                this.focusedOptionIndex = this.autoOptionFocus ? this.findFirstFocusedOptionIndex() : -1;
+                this.$emit('focus', event);
+            },
+            onListBlur(event) {
+                this.focused = false;
+                this.focusedOptionIndex = this.startRangeIndex = -1;
+                this.searchValue = '';
+                this.$emit('blur', event);
+            },
+            onListKeyDown(event) {
+                switch (event.code) {
+                    case 'ArrowDown':
+                        this.onArrowDownKey(event);
+                        break;
+
+                    case 'ArrowUp':
+                        this.onArrowUpKey(event);
+                        break;
+
+                    case 'Home':
+                        this.onHomeKey(event);
+                        break;
+
+                    case 'End':
+                        this.onEndKey(event);
+                        break;
+
+                    case 'PageDown':
+                        this.onPageDownKey(event);
+                        break;
+
+                    case 'PageUp':
+                        this.onPageUpKey(event);
+                        break;
+
+                    case 'Enter':
+                    case 'Space':
+                        this.onSpaceKey(event);
+                        break;
+
+                    case 'Tab':
+                        //NOOP
+                        break;
+
+                    case 'ShiftLeft':
+                    case 'ShiftRight':
+                        this.onShiftKey(event);
+                        break;
+
+                    default:
+                        if (event.code === 'KeyA' && this.multiple && (event.metaKey || event.ctrlKey)) {
+                            const value = this.visibleOptions.filter(option => this.isValidOption(option)).map(option => this.getOptionValue(option));
+                            this.updateModel(event, value);
+
+                            event.preventDefault();
+                            break;
+                        }
+
+                        if (utils.ObjectUtils.isPrintableCharacter(event.key)) {
+                            this.searchOptions(event, event.key);
+                            event.preventDefault();
+                        }
+
+                        break;
+                }
+            },
+            onOptionSelect(event, option, index = -1) {
                 if (this.disabled || this.isOptionDisabled(option)) {
                     return;
                 }
 
-                if(this.multiple)
-                    this.onOptionSelectMultiple(event, option);
-                else
-                    this.onOptionSelectSingle(event, option);
-
+                this.multiple ? this.onOptionSelectMultiple(event, option) : this.onOptionSelectSingle(event, option);
                 this.optionTouched = false;
+                index !== -1 && (this.focusedOptionIndex = index);
+            },
+            onOptionMouseMove(event, index) {
+                if (this.focusOnHover) {
+                    this.changeFocusedOptionIndex(event, index);
+                }
             },
             onOptionTouchEnd() {
                 if (this.disabled) {
@@ -129,7 +276,6 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
             },
             onOptionSelectMultiple(event, option) {
                 let selected = this.isSelected(option);
-                let valueChanged = false;
                 let value = null;
                 let metaSelection = this.optionTouched ? false : this.metaKeySelection;
 
@@ -137,133 +283,320 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
                     let metaKey = (event.metaKey || event.ctrlKey);
 
                     if (selected) {
-                        if(metaKey)
-                            value = this.removeOption(option);
-                        else
-                            value = [this.getOptionValue(option)];
-
-                        valueChanged = true;
+                        value = metaKey ? this.removeOption(option) : [this.getOptionValue(option)];
                     }
                     else {
                         value = (metaKey) ? this.modelValue || [] : [];
                         value = [...value, this.getOptionValue(option)];
-                        valueChanged = true;
                     }
                 }
                 else {
-                    if (selected)
-                        value = this.removeOption(option);
-                    else
-                        value = [...this.modelValue || [], this.getOptionValue(option)];
-
-                    valueChanged = true;
+                    value = selected ? this.removeOption(option) : [...this.modelValue || [], this.getOptionValue(option)];
                 }
 
-                if(valueChanged) {
+                this.updateModel(event, value);
+            },
+            onOptionSelectRange(event, start = -1, end = -1) {
+                start === -1 && (start = this.findNearestSelectedOptionIndex(end, true));
+                end === -1 && (end = this.findNearestSelectedOptionIndex(start));
+
+                if (start !== -1 && end !== -1) {
+                    const rangeStart = Math.min(start, end);
+                    const rangeEnd = Math.max(start, end);
+                    const value = this.visibleOptions.slice(rangeStart, rangeEnd + 1).filter(option => this.isValidOption(option)).map(option => this.getOptionValue(option));
+
                     this.updateModel(event, value);
                 }
             },
-            isSelected(option) {
-                let selected = false;
-                let optionValue = this.getOptionValue(option);
-
-                if (this.multiple) {
-                    if (this.modelValue) {
-                        for (let val of this.modelValue) {
-                            if (utils.ObjectUtils.equals(val, optionValue, this.equalityKey)) {
-                                selected = true;
-                                break;
-                            }
-                        }
+            onFilterChange(event) {
+                this.$emit('filter', {originalEvent: event, value: event.target.value});
+                this.focusedOptionIndex = this.startRangeIndex = -1;
+            },
+            onFilterBlur() {
+                this.focusedOptionIndex = this.startRangeIndex = -1;
+            },
+            onFilterKeyDown(event) {
+                switch (event.code) {
+                    case 'ArrowDown':
+                        this.onArrowDownKey(event);
+                        break;
+
+                    case 'ArrowUp':
+                        this.onArrowUpKey(event);
+                        break;
+
+                    case 'ArrowLeft':
+                    case 'ArrowRight':
+                        this.onArrowLeftKey(event, true);
+                        break;
+
+                    case 'Home':
+                        this.onHomeKey(event, true);
+                        break;
+
+                    case 'End':
+                        this.onEndKey(event, true);
+                        break;
+
+                    case 'Enter':
+                        this.onEnterKey(event);
+                        break;
+
+                    case 'ShiftLeft':
+                    case 'ShiftRight':
+                        this.onShiftKey(event);
+                        break;
+                }
+            },
+            onArrowDownKey(event) {
+                const optionIndex = this.focusedOptionIndex !== -1 ? this.findNextOptionIndex(this.focusedOptionIndex) : this.findFirstFocusedOptionIndex();
+
+                if (this.multiple && event.shiftKey) {
+                    this.onOptionSelectRange(event, this.startRangeIndex, optionIndex);
+                }
+
+                this.changeFocusedOptionIndex(event, optionIndex);
+                event.preventDefault();
+            },
+            onArrowUpKey(event) {
+                const optionIndex = this.focusedOptionIndex !== -1 ? this.findPrevOptionIndex(this.focusedOptionIndex) : this.findLastFocusedOptionIndex();
+
+                if (this.multiple && event.shiftKey) {
+                    this.onOptionSelectRange(event, optionIndex, this.startRangeIndex);
+                }
+
+                this.changeFocusedOptionIndex(event, optionIndex);
+                event.preventDefault();
+            },
+            onArrowLeftKey(event, pressedInInputText = false) {
+                pressedInInputText && (this.focusedOptionIndex = -1);
+            },
+            onHomeKey(event, pressedInInputText = false) {
+                if (pressedInInputText) {
+                    event.currentTarget.setSelectionRange(0, 0);
+                    this.focusedOptionIndex = -1;
+                }
+                else {
+                    let metaKey = event.metaKey || event.ctrlKey;
+                    let optionIndex = this.findFirstOptionIndex();
+
+                    if (this.multiple && event.shiftKey && metaKey) {
+                        this.onOptionSelectRange(event, optionIndex, this.startRangeIndex);
                     }
+
+                    this.changeFocusedOptionIndex(event, optionIndex);
+                }
+
+                event.preventDefault();
+            },
+            onEndKey(event, pressedInInputText = false) {
+                if (pressedInInputText) {
+                    const target = event.currentTarget;
+                    const len = target.value.length;
+                    target.setSelectionRange(len, len);
+                    this.focusedOptionIndex = -1;
                 }
                 else {
-                    selected = utils.ObjectUtils.equals(this.modelValue, optionValue, this.equalityKey);
+                    let metaKey = event.metaKey || event.ctrlKey;
+                    let optionIndex = this.findLastOptionIndex();
+
+                    if (this.multiple && event.shiftKey && metaKey) {
+                        this.onOptionSelectRange(event, this.startRangeIndex, optionIndex);
+                    }
+
+                    this.changeFocusedOptionIndex(event, optionIndex);
                 }
 
-                return selected;
+                event.preventDefault();
             },
-            removeOption(option) {
-                return this.modelValue.filter(val => !utils.ObjectUtils.equals(val, this.getOptionValue(option), this.equalityKey));
+            onPageUpKey(event) {
+                this.scrollInView(0);
+                event.preventDefault();
             },
-            updateModel(event, value) {
-                this.$emit('update:modelValue', value);
-                this.$emit('change', {originalEvent: event, value: value});
+            onPageDownKey(event) {
+                this.scrollInView(this.visibleOptions.length - 1);
+                event.preventDefault();
             },
-            onOptionKeyDown(event, option) {
-                let item = event.currentTarget;
+            onEnterKey(event) {
+                if (this.focusedOptionIndex !== -1) {
+                    if (this.multiple && event.shiftKey)
+                        this.onOptionSelectRange(event, this.focusedOptionIndex);
+                    else
+                        this.onOptionSelect(event, this.visibleOptions[this.focusedOptionIndex]);
+                }
 
-                switch (event.which) {
-                    //down
-                    case 40:
-                        var nextItem = this.findNextItem(item);
-                        if(nextItem) {
-                            nextItem.focus();
-                        }
+                event.preventDefault();
+            },
+            onSpaceKey(event) {
+                this.onEnterKey(event);
+            },
+            onShiftKey() {
+                this.startRangeIndex = this.focusedOptionIndex;
+            },
+            isOptionMatched(option) {
+                return this.isValidOption(option) && this.getOptionLabel(option).toLocaleLowerCase(this.filterLocale).startsWith(this.searchValue.toLocaleLowerCase(this.filterLocale));
+            },
+            isValidOption(option) {
+                return option && !(this.isOptionDisabled(option) || this.isOptionGroup(option));
+            },
+            isValidSelectedOption(option) {
+                return this.isValidOption(option) && this.isSelected(option);
+            },
+            isSelected(option) {
+                const optionValue = this.getOptionValue(option);
+
+                if (this.multiple)
+                    return (this.modelValue || []).some(value => utils.ObjectUtils.equals(value, optionValue, this.equalityKey));
+                else
+                    return utils.ObjectUtils.equals(this.modelValue, optionValue, this.equalityKey);
+            },
+            findFirstOptionIndex() {
+                return this.visibleOptions.findIndex(option => this.isValidOption(option));
+            },
+            findLastOptionIndex() {
+                return utils.ObjectUtils.findLastIndex(this.visibleOptions, option => this.isValidOption(option));
+            },
+            findNextOptionIndex(index) {
+                const matchedOptionIndex = index < (this.visibleOptions.length - 1) ? this.visibleOptions.slice(index + 1).findIndex(option => this.isValidOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex + index + 1 : index;
+            },
+            findPrevOptionIndex(index) {
+                const matchedOptionIndex = index > 0 ? utils.ObjectUtils.findLastIndex(this.visibleOptions.slice(0, index), option => this.isValidOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex : index;
+            },
+            findFirstSelectedOptionIndex() {
+                return this.hasSelectedOption ? this.visibleOptions.findIndex(option => this.isValidSelectedOption(option)) : -1;
+            },
+            findLastSelectedOptionIndex() {
+                return this.hasSelectedOption ? utils.ObjectUtils.findLastIndex(this.visibleOptions, option => this.isValidSelectedOption(option)) : -1;
+            },
+            findNextSelectedOptionIndex(index) {
+                const matchedOptionIndex = this.hasSelectedOption && index < (this.visibleOptions.length - 1) ? this.visibleOptions.slice(index + 1).findIndex(option => this.isValidSelectedOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex + index + 1 : -1;
+            },
+            findPrevSelectedOptionIndex(index) {
+                const matchedOptionIndex = this.hasSelectedOption && index > 0 ? utils.ObjectUtils.findLastIndex(this.visibleOptions.slice(0, index), option => this.isValidSelectedOption(option)) : -1;
+                return matchedOptionIndex > -1 ? matchedOptionIndex : -1;
+            },
+            findNearestSelectedOptionIndex(index, firstCheckUp = false) {
+                let matchedOptionIndex = -1;
 
-                        event.preventDefault();
-                    break;
+                if (this.hasSelectedOption) {
+                    if (firstCheckUp) {
+                        matchedOptionIndex = this.findPrevSelectedOptionIndex(index);
+                        matchedOptionIndex = matchedOptionIndex === -1 ? this.findNextSelectedOptionIndex(index) : matchedOptionIndex;
+                    }
+                    else {
+                        matchedOptionIndex = this.findNextSelectedOptionIndex(index);
+                        matchedOptionIndex = matchedOptionIndex === -1 ? this.findPrevSelectedOptionIndex(index) : matchedOptionIndex;
+                    }
+                }
 
-                    //up
-                    case 38:
-                        var prevItem = this.findPrevItem(item);
-                        if(prevItem) {
-                            prevItem.focus();
-                        }
+                return matchedOptionIndex > -1 ? matchedOptionIndex : index;
+            },
+            findFirstFocusedOptionIndex() {
+                const selectedIndex = this.findFirstSelectedOptionIndex();
+                return selectedIndex < 0 ? this.findFirstOptionIndex() : selectedIndex;
+            },
+            findLastFocusedOptionIndex() {
+                const selectedIndex = this.findLastSelectedOptionIndex();
+                return selectedIndex < 0 ? this.findLastOptionIndex() : selectedIndex;
+            },
+            searchOptions(event, char) {
+                this.searchValue = (this.searchValue || '') + char;
+
+                let optionIndex = -1;
+                if (this.focusedOptionIndex !== -1) {
+                    optionIndex = this.visibleOptions.slice(this.focusedOptionIndex).findIndex(option => this.isOptionMatched(option));
+                    optionIndex = optionIndex === -1 ? this.visibleOptions.slice(0, this.focusedOptionIndex).findIndex(option => this.isOptionMatched(option)) : optionIndex + this.focusedOptionIndex;
+                }
+                else {
+                    optionIndex = this.visibleOptions.findIndex(option => this.isOptionMatched(option));
+                }
 
-                        event.preventDefault();
-                    break;
+                if (optionIndex === -1 && this.focusedOptionIndex === -1) {
+                    optionIndex = this.findFirstFocusedOptionIndex();
+                }
 
-                    //enter
-                    case 13:
-                        this.onOptionSelect(event, option);
-                        event.preventDefault();
-                    break;
+                if (optionIndex !== -1) {
+                    this.changeFocusedOptionIndex(event, optionIndex);
                 }
+
+                if (this.searchTimeout) {
+                    clearTimeout(this.searchTimeout);
+                }
+
+                this.searchTimeout = setTimeout(() => {
+                    this.searchValue = '';
+                    this.searchTimeout = null;
+                }, 500);
+            },
+            removeOption(option) {
+                return this.modelValue.filter(val => !utils.ObjectUtils.equals(val, this.getOptionValue(option), this.equalityKey));
             },
-            findNextItem(item) {
-                let nextItem = item.nextElementSibling;
+            changeFocusedOptionIndex(event, index) {
+                if (this.focusedOptionIndex !== index) {
+                    this.focusedOptionIndex = index;
+                    this.scrollInView();
 
-                if (nextItem)
-                    return utils.DomHandler.hasClass(nextItem, 'p-disabled') || utils.DomHandler.hasClass(nextItem, 'p-listbox-item-group') ? this.findNextItem(nextItem) : nextItem;
-                else
-                    return null;
+                    if (this.selectOnFocus && !this.multiple) {
+                        this.updateModel(event, this.getOptionValue(this.visibleOptions[index]));
+                    }
+                }
+            },
+            scrollInView(index = -1) {
+                const id = index !== -1 ? `${this.id}_${index}` : this.focusedOptionId;
+                const element = utils.DomHandler.findSingle(this.list, `li[id="${id}"]`);
+                if (element) {
+                    element.scrollIntoView && element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                }
+                else if (!this.virtualScrollerDisabled) {
+                    this.virtualScroller && this.virtualScroller.scrollToIndex(index !== -1 ? index : this.focusedOptionIndex);
+                }
+            },
+            autoUpdateModel() {
+                if (this.selectOnFocus && this.autoOptionFocus && !this.hasSelectedOption) {
+                    this.focusedOptionIndex = this.findFirstFocusedOptionIndex();
+                    const value = this.getOptionValue(this.visibleOptions[this.focusedOptionIndex]);
+                    this.updateModel(null, this.multiple ? [value] : value);
+                }
+            },
+            updateModel(event, value) {
+                this.$emit('update:modelValue', value);
+                this.$emit('change', { originalEvent: event, value });
             },
-            findPrevItem(item) {
-                let prevItem = item.previousElementSibling;
+            flatOptions(options) {
+                return (options || []).reduce((result, option, index) => {
+                    result.push({ optionGroup: option, group: true, index });
 
-                if (prevItem)
-                    return utils.DomHandler.hasClass(prevItem, 'p-disabled') || utils.DomHandler.hasClass(prevItem, 'p-listbox-item-group') ? this.findPrevItem(prevItem) : prevItem;
-                else
-                    return null;
+                    const optionGroupChildren = this.getOptionGroupChildren(option);
+                    optionGroupChildren && optionGroupChildren.forEach(o => result.push(o));
+
+                    return result;
+                }, []);
             },
-            onFilterChange(event) {
-                this.$emit('filter', {originalEvent: event, value: event.target.value});
+            listRef(el, contentRef) {
+                this.list = el;
+                contentRef && contentRef(el); // For VirtualScroller
             },
             virtualScrollerRef(el) {
                 this.virtualScroller = el;
             }
         },
         computed: {
+            containerClass() {
+                return ['p-listbox p-component', {
+                    'p-focus': this.focused,
+                    'p-disabled': this.disabled
+                }];
+            },
             visibleOptions() {
-                if (this.filterValue) {
-                    if (this.optionGroupLabel) {
-                        let filteredGroups = [];
-                        for (let optgroup of this.options) {
-                            let filteredSubOptions = api.FilterService.filter(this.getOptionGroupChildren(optgroup), this.searchFields, this.filterValue, this.filterMatchMode, this.filterLocale);
-                            if (filteredSubOptions && filteredSubOptions.length) {
-                                filteredGroups.push({...optgroup, ...{items: filteredSubOptions}});
-                            }
-                        }
-                        return filteredGroups
-                    }
-                    else {
-                        return api.FilterService.filter(this.options, this.searchFields, this.filterValue, 'contains', this.filterLocale);
-                    }
-                }
-                else {
-                    return this.options;
-                }
+                const options = this.optionGroupLabel ? this.flatOptions(this.options) : (this.options || []);
+
+                return this.filterValue ? api.FilterService.filter(options, this.searchFields, this.filterValue, this.filterMatchMode, this.filterLocale) : options;
+            },
+            hasSelectedOption() {
+                return utils.ObjectUtils.isNotEmpty(this.modelValue);
             },
             equalityKey() {
                 return this.optionValue ? null : this.dataKey;
@@ -271,11 +604,32 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
             searchFields() {
                 return this.filterFields || [this.optionLabel];
             },
+            filterResultMessageText() {
+                return utils.ObjectUtils.isNotEmpty(this.visibleOptions) ? this.filterMessageText.replaceAll('{0}', this.visibleOptions.length) : this.emptyFilterMessageText;
+            },
+            filterMessageText() {
+                return this.filterMessage || this.$primevue.config.locale.searchMessage || '';
+            },
             emptyFilterMessageText() {
-                return this.emptyFilterMessage || this.$primevue.config.locale.emptyFilterMessage;
+                return this.emptyFilterMessage || this.$primevue.config.locale.emptySearchMessage || this.$primevue.config.locale.emptyFilterMessage || '';
             },
             emptyMessageText() {
-                return this.emptyMessage || this.$primevue.config.locale.emptyMessage;
+                return this.emptyMessage || this.$primevue.config.locale.emptyMessage || '';
+            },
+            selectionMessageText() {
+                return this.selectionMessage || this.$primevue.config.locale.selectionMessage || '';
+            },
+            emptySelectionMessageText() {
+                return this.emptySelectionMessage || this.$primevue.config.locale.emptySelectionMessage || '';
+            },
+            selectedMessageText() {
+                return this.hasSelectedOption ? this.selectionMessageText.replaceAll('{0}', this.multiple ? this.modelValue.length : '1') : this.emptySelectionMessageText;
+            },
+            focusedOptionId() {
+                return this.focusedOptionIndex !== -1 ? `${this.id}_${this.focusedOptionIndex}` : null;
+            },
+            ariaSetSize() {
+                return this.visibleOptions.filter(option => !this.isOptionGroup(option)).length;
             },
             virtualScrollerDisabled() {
                 return !this.virtualScrollerOptions;
@@ -289,141 +643,183 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
         }
     };
 
-    const _hoisted_1 = { class: "p-listbox p-component" };
-    const _hoisted_2 = {
+    const _hoisted_1 = ["id"];
+    const _hoisted_2 = ["tabindex"];
+    const _hoisted_3 = {
       key: 0,
       class: "p-listbox-header"
     };
-    const _hoisted_3 = { class: "p-listbox-filter-container" };
-    const _hoisted_4 = ["placeholder"];
-    const _hoisted_5 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-listbox-filter-icon pi pi-search" }, null, -1);
-    const _hoisted_6 = ["tabindex", "onClick", "onKeydown", "aria-label", "aria-selected"];
-    const _hoisted_7 = { class: "p-listbox-item-group" };
-    const _hoisted_8 = ["tabindex", "onClick", "onKeydown", "aria-label", "aria-selected"];
-    const _hoisted_9 = {
-      key: 2,
-      class: "p-listbox-empty-message"
+    const _hoisted_4 = { class: "p-listbox-filter-container" };
+    const _hoisted_5 = ["placeholder", "aria-owns", "aria-activedescendant", "tabindex"];
+    const _hoisted_6 = /*#__PURE__*/vue.createElementVNode("span", { class: "p-listbox-filter-icon pi pi-search" }, null, -1);
+    const _hoisted_7 = {
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
     };
-    const _hoisted_10 = {
-      key: 3,
-      class: "p-listbox-empty-message"
+    const _hoisted_8 = ["id", "aria-multiselectable", "aria-label", "aria-labelledby", "aria-activedescendant", "aria-disabled"];
+    const _hoisted_9 = ["id"];
+    const _hoisted_10 = ["id", "aria-label", "aria-selected", "aria-disabled", "aria-setsize", "aria-posinset", "onClick", "onMousemove"];
+    const _hoisted_11 = {
+      key: 0,
+      class: "p-listbox-empty-message",
+      role: "option"
+    };
+    const _hoisted_12 = {
+      key: 1,
+      class: "p-listbox-empty-message",
+      role: "option"
+    };
+    const _hoisted_13 = {
+      key: 0,
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
+    };
+    const _hoisted_14 = {
+      role: "status",
+      "aria-live": "polite",
+      class: "p-hidden-accessible"
     };
+    const _hoisted_15 = ["tabindex"];
 
     function render(_ctx, _cache, $props, $setup, $data, $options) {
       const _component_VirtualScroller = vue.resolveComponent("VirtualScroller");
       const _directive_ripple = vue.resolveDirective("ripple");
 
-      return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+      return (vue.openBlock(), vue.createElementBlock("div", {
+        id: $data.id,
+        class: vue.normalizeClass($options.containerClass),
+        onFocusout: _cache[10] || (_cache[10] = (...args) => ($options.onFocusout && $options.onFocusout(...args)))
+      }, [
+        vue.createElementVNode("span", {
+          ref: "firstHiddenFocusableElement",
+          role: "presentation",
+          "aria-hidden": "true",
+          class: "p-hidden-accessible p-hidden-focusable",
+          tabindex: !$props.disabled ? $props.tabindex : -1,
+          onFocus: _cache[0] || (_cache[0] = (...args) => ($options.onFirstHiddenFocus && $options.onFirstHiddenFocus(...args)))
+        }, null, 40, _hoisted_2),
         vue.renderSlot(_ctx.$slots, "header", {
           value: $props.modelValue,
           options: $options.visibleOptions
         }),
         ($props.filter)
-          ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
-              vue.createElementVNode("div", _hoisted_3, [
-                vue.withDirectives(vue.createElementVNode("input", {
+          ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3, [
+              vue.createElementVNode("div", _hoisted_4, [
+                vue.withDirectives(vue.createElementVNode("input", vue.mergeProps({
+                  ref: "filterInput",
                   type: "text",
                   class: "p-listbox-filter p-inputtext p-component",
-                  "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => (($data.filterValue) = $event)),
+                  "onUpdate:modelValue": _cache[1] || (_cache[1] = $event => (($data.filterValue) = $event)),
                   placeholder: $props.filterPlaceholder,
-                  onInput: _cache[1] || (_cache[1] = (...args) => ($options.onFilterChange && $options.onFilterChange(...args)))
-                }, null, 40, _hoisted_4), [
+                  role: "searchbox",
+                  autocomplete: "off",
+                  "aria-owns": $data.id + '_list',
+                  "aria-activedescendant": $options.focusedOptionId,
+                  tabindex: !$props.disabled && !$data.focused ? $props.tabindex : -1,
+                  onInput: _cache[2] || (_cache[2] = (...args) => ($options.onFilterChange && $options.onFilterChange(...args))),
+                  onBlur: _cache[3] || (_cache[3] = (...args) => ($options.onFilterBlur && $options.onFilterBlur(...args))),
+                  onKeydown: _cache[4] || (_cache[4] = (...args) => ($options.onFilterKeyDown && $options.onFilterKeyDown(...args)))
+                }, $props.filterInputProps), null, 16, _hoisted_5), [
                   [vue.vModelText, $data.filterValue]
                 ]),
-                _hoisted_5
-              ])
+                _hoisted_6
+              ]),
+              vue.createElementVNode("span", _hoisted_7, vue.toDisplayString($options.filterResultMessageText), 1)
             ]))
           : vue.createCommentVNode("", true),
         vue.createElementVNode("div", {
+          ref: "listWrapper",
           class: "p-listbox-list-wrapper",
           style: vue.normalizeStyle($props.listStyle)
         }, [
           vue.createVNode(_component_VirtualScroller, vue.mergeProps({ ref: $options.virtualScrollerRef }, $props.virtualScrollerOptions, {
             style: $props.listStyle,
             items: $options.visibleOptions,
+            tabindex: -1,
             disabled: $options.virtualScrollerDisabled
           }), vue.createSlots({
-            content: vue.withCtx(({ styleClass, contentRef, items, getItemOptions, contentStyle }) => [
+            content: vue.withCtx(({ styleClass, contentRef, items, getItemOptions, contentStyle, itemSize }) => [
               vue.createElementVNode("ul", {
-                ref: contentRef,
+                ref: (el) => $options.listRef(el, contentRef),
+                id: $data.id + '_list',
                 class: vue.normalizeClass(['p-listbox-list', styleClass]),
                 style: vue.normalizeStyle(contentStyle),
+                tabindex: -1,
                 role: "listbox",
-                "aria-multiselectable": "multiple"
+                "aria-multiselectable": $props.multiple,
+                "aria-label": _ctx.ariaLabel,
+                "aria-labelledby": _ctx.ariaLabelledby,
+                "aria-activedescendant": $data.focused ? $options.focusedOptionId : undefined,
+                "aria-disabled": $props.disabled,
+                onFocus: _cache[6] || (_cache[6] = (...args) => ($options.onListFocus && $options.onListFocus(...args))),
+                onBlur: _cache[7] || (_cache[7] = (...args) => ($options.onListBlur && $options.onListBlur(...args))),
+                onKeydown: _cache[8] || (_cache[8] = (...args) => ($options.onListKeyDown && $options.onListKeyDown(...args)))
               }, [
-                (!$props.optionGroupLabel)
-                  ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(items, (option, i) => {
-                      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
-                        tabindex: $options.isOptionDisabled(option) ? null : '0',
-                        class: vue.normalizeClass(['p-listbox-item', {'p-highlight': $options.isSelected(option), 'p-disabled': $options.isOptionDisabled(option)}]),
-                        key: $options.getOptionRenderKey(option),
-                        onClick: $event => ($options.onOptionSelect($event, option)),
-                        onTouchend: _cache[2] || (_cache[2] = $event => ($options.onOptionTouchEnd())),
-                        onKeydown: $event => ($options.onOptionKeyDown($event, option)),
-                        role: "option",
-                        "aria-label": $options.getOptionLabel(option),
-                        "aria-selected": $options.isSelected(option)
-                      }, [
-                        vue.renderSlot(_ctx.$slots, "option", {
-                          option: option,
-                          index: $options.getOptionIndex(i, getItemOptions)
-                        }, () => [
-                          vue.createTextVNode(vue.toDisplayString($options.getOptionLabel(option)), 1)
-                        ])
-                      ], 42, _hoisted_6)), [
-                        [_directive_ripple]
-                      ])
-                    }), 128))
-                  : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(items, (optionGroup, i) => {
-                      return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
-                        key: $options.getOptionGroupRenderKey(optionGroup)
-                      }, [
-                        vue.createElementVNode("li", _hoisted_7, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(items, (option, i) => {
+                  return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+                    key: $options.getOptionRenderKey(option, $options.getOptionIndex(i, getItemOptions))
+                  }, [
+                    ($options.isOptionGroup(option))
+                      ? (vue.openBlock(), vue.createElementBlock("li", {
+                          key: 0,
+                          id: $data.id + '_' + $options.getOptionIndex(i, getItemOptions),
+                          style: vue.normalizeStyle({height: itemSize ? itemSize + 'px' : undefined}),
+                          class: "p-listbox-item-group",
+                          role: "option"
+                        }, [
                           vue.renderSlot(_ctx.$slots, "optiongroup", {
-                            option: optionGroup,
+                            option: option.optionGroup,
                             index: $options.getOptionIndex(i, getItemOptions)
                           }, () => [
-                            vue.createTextVNode(vue.toDisplayString($options.getOptionGroupLabel(optionGroup)), 1)
+                            vue.createTextVNode(vue.toDisplayString($options.getOptionGroupLabel(option.optionGroup)), 1)
                           ])
-                        ]),
-                        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList($options.getOptionGroupChildren(optionGroup), (option, i) => {
-                          return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
-                            tabindex: $options.isOptionDisabled(option) ? null : '0',
-                            class: vue.normalizeClass(['p-listbox-item', {'p-highlight': $options.isSelected(option), 'p-disabled': $options.isOptionDisabled(option)}]),
-                            key: $options.getOptionRenderKey(option),
-                            onClick: $event => ($options.onOptionSelect($event, option)),
-                            onTouchend: _cache[3] || (_cache[3] = $event => ($options.onOptionTouchEnd())),
-                            onKeydown: $event => ($options.onOptionKeyDown($event, option)),
-                            role: "option",
-                            "aria-label": $options.getOptionLabel(option),
-                            "aria-selected": $options.isSelected(option)
-                          }, [
-                            vue.renderSlot(_ctx.$slots, "option", {
-                              option: option,
-                              index: $options.getOptionIndex(i, getItemOptions)
-                            }, () => [
-                              vue.createTextVNode(vue.toDisplayString($options.getOptionLabel(option)), 1)
-                            ])
-                          ], 42, _hoisted_8)), [
-                            [_directive_ripple]
+                        ], 12, _hoisted_9))
+                      : vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
+                          key: 1,
+                          id: $data.id + '_' + $options.getOptionIndex(i, getItemOptions),
+                          style: vue.normalizeStyle({height: itemSize ? itemSize + 'px' : undefined}),
+                          class: vue.normalizeClass(['p-listbox-item', {'p-highlight': $options.isSelected(option), 'p-focus': $data.focusedOptionIndex === $options.getOptionIndex(i, getItemOptions), 'p-disabled': $options.isOptionDisabled(option)}]),
+                          role: "option",
+                          "aria-label": $options.getOptionLabel(option),
+                          "aria-selected": $options.isSelected(option),
+                          "aria-disabled": $options.isOptionDisabled(option),
+                          "aria-setsize": $options.ariaSetSize,
+                          "aria-posinset": $options.getAriaPosInset($options.getOptionIndex(i, getItemOptions)),
+                          onClick: $event => ($options.onOptionSelect($event, option, $options.getOptionIndex(i, getItemOptions))),
+                          onMousemove: $event => ($options.onOptionMouseMove($event, $options.getOptionIndex(i, getItemOptions))),
+                          onTouchend: _cache[5] || (_cache[5] = $event => ($options.onOptionTouchEnd()))
+                        }, [
+                          vue.renderSlot(_ctx.$slots, "option", {
+                            option: option,
+                            index: $options.getOptionIndex(i, getItemOptions)
+                          }, () => [
+                            vue.createTextVNode(vue.toDisplayString($options.getOptionLabel(option)), 1)
                           ])
-                        }), 128))
-                      ], 64))
-                    }), 128)),
+                        ], 46, _hoisted_10)), [
+                          [_directive_ripple]
+                        ])
+                  ], 64))
+                }), 128)),
                 ($data.filterValue && (!items || (items && items.length === 0)))
-                  ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_9, [
+                  ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_11, [
                       vue.renderSlot(_ctx.$slots, "emptyfilter", {}, () => [
                         vue.createTextVNode(vue.toDisplayString($options.emptyFilterMessageText), 1)
                       ])
                     ]))
                   : ((!$props.options || ($props.options && $props.options.length === 0)))
-                    ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_10, [
+                    ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_12, [
                         vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                           vue.createTextVNode(vue.toDisplayString($options.emptyMessageText), 1)
                         ])
                       ]))
                     : vue.createCommentVNode("", true)
-              ], 6)
+              ], 46, _hoisted_8),
+              ((!$props.options || ($props.options && $props.options.length === 0)))
+                ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_13, vue.toDisplayString($options.emptyMessageText), 1))
+                : vue.createCommentVNode("", true),
+              vue.createElementVNode("span", _hoisted_14, vue.toDisplayString($options.selectedMessageText), 1)
             ]),
             _: 2
           }, [
@@ -440,8 +836,16 @@ this.primevue.listbox = (function (utils, api, Ripple, VirtualScroller, vue) {
         vue.renderSlot(_ctx.$slots, "footer", {
           value: $props.modelValue,
           options: $options.visibleOptions
-        })
-      ]))
+        }),
+        vue.createElementVNode("span", {
+          ref: "lastHiddenFocusableElement",
+          role: "presentation",
+          "aria-hidden": "true",
+          class: "p-hidden-accessible p-hidden-focusable",
+          tabindex: !$props.disabled ? $props.tabindex : -1,
+          onFocus: _cache[9] || (_cache[9] = (...args) => ($options.onLastHiddenFocus && $options.onLastHiddenFocus(...args)))
+        }, null, 40, _hoisted_15)
+      ], 42, _hoisted_1))
     }
 
     function styleInject(css, ref) {