primevue 3.15.0 → 3.16.2

package/listbox/listbox.cjs.js

@@ -13,7 +13,7 @@ var VirtualScroller__default = /*#__PURE__*/_interopDefaultLegacy(VirtualScrolle
 
 var script = {
     name: 'Listbox',
-    emits: ['update:modelValue', 'change', 'filter'],
+    emits: ['update:modelValue', 'change', 'focus', 'blur', 'filter'],
     props: {
         modelValue: null,
         options: Array,
@@ -38,6 +38,27 @@ var script = {
             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
@@ -46,17 +67,44 @@ var script = {
             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) {
@@ -68,14 +116,14 @@ var script = {
         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);
@@ -83,17 +131,116 @@ var script = {
         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) {
@@ -133,7 +280,6 @@ var script = {
         },
         onOptionSelectMultiple(event, option) {
             let selected = this.isSelected(option);
-            let valueChanged = false;
             let value = null;
             let metaSelection = this.optionTouched ? false : this.metaKeySelection;
 
@@ -141,133 +287,320 @@ var script = {
                 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;
@@ -275,11 +608,32 @@ var script = {
         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;
@@ -293,141 +647,183 @@ var script = {
     }
 };
 
-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
       }, [
@@ -444,8 +840,16 @@ function render(_ctx, _cache, $props, $setup, $data, $options) {
     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) {