@vaadin/combo-box 23.2.0-alpha1 → 23.2.0-alpha4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/combo-box",
-  "version": "23.2.0-alpha1",
+  "version": "23.2.0-alpha4",
   "publishConfig": {
     "access": "public"
   },
@@ -24,7 +24,9 @@
     "src",
     "theme",
     "vaadin-*.d.ts",
-    "vaadin-*.js"
+    "vaadin-*.js",
+    "web-types.json",
+    "web-types.lit.json"
   ],
   "keywords": [
     "Vaadin",
@@ -36,23 +38,27 @@
   "dependencies": {
     "@open-wc/dedupe-mixin": "^1.3.0",
     "@polymer/polymer": "^3.0.0",
-    "@vaadin/component-base": "23.2.0-alpha1",
-    "@vaadin/field-base": "23.2.0-alpha1",
-    "@vaadin/input-container": "23.2.0-alpha1",
-    "@vaadin/item": "23.2.0-alpha1",
-    "@vaadin/lit-renderer": "23.2.0-alpha1",
-    "@vaadin/vaadin-lumo-styles": "23.2.0-alpha1",
-    "@vaadin/vaadin-material-styles": "23.2.0-alpha1",
-    "@vaadin/vaadin-overlay": "23.2.0-alpha1",
-    "@vaadin/vaadin-themable-mixin": "23.2.0-alpha1"
+    "@vaadin/component-base": "23.2.0-alpha4",
+    "@vaadin/field-base": "23.2.0-alpha4",
+    "@vaadin/input-container": "23.2.0-alpha4",
+    "@vaadin/item": "23.2.0-alpha4",
+    "@vaadin/lit-renderer": "23.2.0-alpha4",
+    "@vaadin/vaadin-lumo-styles": "23.2.0-alpha4",
+    "@vaadin/vaadin-material-styles": "23.2.0-alpha4",
+    "@vaadin/vaadin-overlay": "23.2.0-alpha4",
+    "@vaadin/vaadin-themable-mixin": "23.2.0-alpha4"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4",
-    "@vaadin/polymer-legacy-adapter": "23.2.0-alpha1",
+    "@vaadin/polymer-legacy-adapter": "23.2.0-alpha4",
     "@vaadin/testing-helpers": "^0.3.2",
-    "@vaadin/text-field": "23.2.0-alpha1",
+    "@vaadin/text-field": "23.2.0-alpha4",
     "lit": "^2.0.0",
     "sinon": "^13.0.2"
   },
-  "gitHead": "f226a2976c270d3d53c824f6e0a740a5d3382d91"
+  "web-types": [
+    "web-types.json",
+    "web-types.lit.json"
+  ],
+  "gitHead": "cbf5f1d0f38ac9b81c65cf9ef5660182e176e598"
 }

package/src/lit/renderer-directives.d.ts

@@ -3,10 +3,10 @@
  * Copyright (c) 2017 - 2022 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { TemplateResult } from 'lit';
-import { DirectiveResult } from 'lit/directive.js';
+import type { TemplateResult } from 'lit';
+import type { DirectiveResult } from 'lit/directive.js';
 import { LitRendererDirective } from '@vaadin/lit-renderer';
-import { ComboBox, ComboBoxItemModel } from '../vaadin-combo-box.js';
+import type { ComboBox, ComboBoxItemModel } from '../vaadin-combo-box.js';
 
 export type ComboBoxLitRenderer<TItem> = (
   item: TItem,

package/src/vaadin-combo-box-data-provider-mixin.d.ts

@@ -3,9 +3,9 @@
  * Copyright (c) 2015 - 2022 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { Constructor } from '@open-wc/dedupe-mixin';
+import type { Constructor } from '@open-wc/dedupe-mixin';
 
-export type ComboBoxDataProviderCallback<TItem> = (items: TItem[], size: number) => void;
+export type ComboBoxDataProviderCallback<TItem> = (items: TItem[], size?: number) => void;
 
 export interface ComboBoxDataProviderParams {
   page: number;
@@ -20,7 +20,7 @@ export type ComboBoxDataProvider<TItem> = (
 
 export declare function ComboBoxDataProviderMixin<TItem, T extends Constructor<HTMLElement>>(
   base: T,
-): T & Constructor<ComboBoxDataProviderMixinClass<TItem>>;
+): Constructor<ComboBoxDataProviderMixinClass<TItem>> & T;
 
 export declare class ComboBoxDataProviderMixinClass<TItem> {
   /**

package/src/vaadin-combo-box-data-provider-mixin.js

@@ -62,13 +62,17 @@ export const ComboBoxDataProviderMixin = (superClass) =>
         __placeHolder: {
           value: new ComboBoxPlaceholder(),
         },
+
+        /** @private */
+        __previousDataProviderFilter: {
+          type: String,
+        },
       };
     }
 
     static get observers() {
       return [
-        '_dataProviderFilterChanged(filter, dataProvider)',
-        '_dataProviderClearFilter(dataProvider, opened, value)',
+        '_dataProviderFilterChanged(filter)',
         '_warnDataProviderValue(dataProvider, value)',
         '_ensureFirstPage(opened)',
       ];
@@ -77,7 +81,6 @@ export const ComboBoxDataProviderMixin = (superClass) =>
     /** @protected */
     ready() {
       super.ready();
-      this.clearCache();
       this._scroller.addEventListener('index-requested', (e) => {
         const index = e.detail.index;
         const currentScrollerPos = e.detail.currentScrollerPos;
@@ -101,38 +104,25 @@ export const ComboBoxDataProviderMixin = (superClass) =>
     }
 
     /** @private */
-    _dataProviderFilterChanged() {
-      if (!this._shouldFetchData()) {
+    _dataProviderFilterChanged(filter) {
+      if (this.__previousDataProviderFilter === undefined && filter === '') {
+        this.__previousDataProviderFilter = filter;
         return;
       }
 
-      this._refreshData();
-    }
+      if (this.__previousDataProviderFilter !== filter) {
+        this.__previousDataProviderFilter = filter;
 
-    /** @private */
-    _dataProviderClearFilter(dataProvider, opened, value) {
-      // Can't depend on filter in this observer as we don't want
-      // to clear the filter whenever it's set
-      if (dataProvider && !this.loading && this.filter && !(opened && this.autoOpenDisabled && value === this.filter)) {
-        this._refreshData(true);
-      }
-    }
+        this._pendingRequests = {};
+        // Immediately mark as loading if this refresh leads to re-fetching pages
+        // This prevents some issues with the properties below triggering
+        // observers that also rely on the loading state
+        this.loading = this._shouldFetchData();
+        // Reset size and internal loading state
+        this.size = undefined;
 
-    /** @private */
-    _refreshData(clearFilter) {
-      // Immediately mark as loading if this refresh leads to re-fetching pages
-      // This prevents some issues with the properties below triggering
-      // observers that also rely on the loading state
-      this.loading = this._shouldFetchData();
-      // Reset size and internal loading state
-      this.size = undefined;
-      this._pendingRequests = {};
-      // Clear filter if requested
-      if (clearFilter) {
-        this.filter = '';
+        this.clearCache();
       }
-      // Clear cached pages, and reload current page if we need the data
-      this.clearCache();
     }
 
     /** @private */
@@ -196,10 +186,13 @@ export const ComboBoxDataProviderMixin = (superClass) =>
         filteredItems.splice(params.page * params.pageSize, items.length, ...items);
         this.filteredItems = filteredItems;
 
-        if (!this.opened && !this.hasAttribute('focused')) {
+        if (!this.opened && !this._isInputFocused()) {
           this._commitValue();
         }
-        this.size = size;
+
+        if (size !== undefined) {
+          this.size = size;
+        }
 
         delete this._pendingRequests[page];
 
@@ -229,13 +222,16 @@ export const ComboBoxDataProviderMixin = (superClass) =>
       if (!this.dataProvider) {
         return;
       }
+
       this._pendingRequests = {};
       const filteredItems = [];
       for (let i = 0; i < (this.size || 0); i++) {
         filteredItems.push(this.__placeHolder);
       }
       this.filteredItems = filteredItems;
+
       if (this._shouldFetchData()) {
+        this._forceNextRequest = false;
         this._loadPage(0);
       } else {
         this._forceNextRequest = true;
@@ -269,6 +265,8 @@ export const ComboBoxDataProviderMixin = (superClass) =>
       this._ensureItemsOrDataProvider(() => {
         this.dataProvider = oldDataProvider;
       });
+
+      this.clearCache();
     }
 
     /** @private */

package/src/vaadin-combo-box-light.d.ts

@@ -3,13 +3,13 @@
  * Copyright (c) 2015 - 2022 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { DisabledMixinClass } from '@vaadin/component-base/src/disabled-mixin.js';
-import { KeyboardMixinClass } from '@vaadin/component-base/src/keyboard-mixin.js';
-import { InputMixinClass } from '@vaadin/field-base/src/input-mixin.js';
-import { ThemableMixinClass } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
-import { ComboBoxDataProviderMixinClass } from './vaadin-combo-box-data-provider-mixin.js';
-import { ComboBoxMixinClass } from './vaadin-combo-box-mixin.js';
-import { ComboBoxDefaultItem } from './vaadin-combo-box-mixin.js';
+import type { DisabledMixinClass } from '@vaadin/component-base/src/disabled-mixin.js';
+import type { KeyboardMixinClass } from '@vaadin/component-base/src/keyboard-mixin.js';
+import type { InputMixinClass } from '@vaadin/field-base/src/input-mixin.js';
+import type { ValidateMixinClass } from '@vaadin/field-base/src/validate-mixin.js';
+import type { ThemableMixinClass } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import type { ComboBoxDataProviderMixinClass } from './vaadin-combo-box-data-provider-mixin.js';
+import type { ComboBoxDefaultItem, ComboBoxMixinClass } from './vaadin-combo-box-mixin.js';
 export {
   ComboBoxDataProvider,
   ComboBoxDataProviderCallback,
@@ -54,6 +54,11 @@ export type ComboBoxLightFilterChangedEvent = CustomEvent<{ value: string }>;
  */
 export type ComboBoxLightSelectedItemChangedEvent<TItem> = CustomEvent<{ value: TItem | null | undefined }>;
 
+/**
+ * Fired whenever the field is validated.
+ */
+export type ComboBoxLightValidatedEvent = CustomEvent<{ valid: boolean }>;
+
 export interface ComboBoxLightEventMap<TItem> extends HTMLElementEventMap {
   change: ComboBoxLightChangeEvent<TItem>;
 
@@ -68,6 +73,8 @@ export interface ComboBoxLightEventMap<TItem> extends HTMLElementEventMap {
   'value-changed': ComboBoxLightValueChangedEvent;
 
   'selected-item-changed': ComboBoxLightSelectedItemChangedEvent<TItem>;
+
+  validated: ComboBoxLightValidatedEvent;
 }
 
 /**
@@ -114,6 +121,7 @@ export interface ComboBoxLightEventMap<TItem> extends HTMLElementEventMap {
  * @fires {CustomEvent} opened-changed - Fired when the `opened` property changes.
  * @fires {CustomEvent} selected-item-changed - Fired when the `selectedItem` property changes.
  * @fires {CustomEvent} value-changed - Fired when the `value` property changes.
+ * @fires {CustomEvent} validated - Fired whenever the field is validated.
  */
 declare class ComboBoxLight<TItem = ComboBoxDefaultItem> extends HTMLElement {
   /**
@@ -126,13 +134,13 @@ declare class ComboBoxLight<TItem = ComboBoxDefaultItem> extends HTMLElement {
   addEventListener<K extends keyof ComboBoxLightEventMap<TItem>>(
     type: K,
     listener: (this: ComboBoxLight<TItem>, ev: ComboBoxLightEventMap<TItem>[K]) => void,
-    options?: boolean | AddEventListenerOptions,
+    options?: AddEventListenerOptions | boolean,
   ): void;
 
   removeEventListener<K extends keyof ComboBoxLightEventMap<TItem>>(
     type: K,
     listener: (this: ComboBoxLight<TItem>, ev: ComboBoxLightEventMap<TItem>[K]) => void,
-    options?: boolean | EventListenerOptions,
+    options?: EventListenerOptions | boolean,
   ): void;
 }
 
@@ -142,7 +150,8 @@ interface ComboBoxLight<TItem = ComboBoxDefaultItem>
     KeyboardMixinClass,
     InputMixinClass,
     DisabledMixinClass,
-    ThemableMixinClass {}
+    ThemableMixinClass,
+    ValidateMixinClass {}
 
 declare global {
   interface HTMLElementTagNameMap {

package/src/vaadin-combo-box-light.js

@@ -8,6 +8,7 @@ import './vaadin-combo-box-overlay.js';
 import './vaadin-combo-box-scroller.js';
 import { dashToCamelCase } from '@polymer/polymer/lib/utils/case-map.js';
 import { html, PolymerElement } from '@polymer/polymer/polymer-element.js';
+import { ValidateMixin } from '@vaadin/field-base/src/validate-mixin.js';
 import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
 import { ComboBoxDataProviderMixin } from './vaadin-combo-box-data-provider-mixin.js';
 import { ComboBoxMixin } from './vaadin-combo-box-mixin.js';
@@ -56,13 +57,15 @@ import { ComboBoxMixin } from './vaadin-combo-box-mixin.js';
  * @fires {CustomEvent} opened-changed - Fired when the `opened` property changes.
  * @fires {CustomEvent} selected-item-changed - Fired when the `selectedItem` property changes.
  * @fires {CustomEvent} value-changed - Fired when the `value` property changes.
+ * @fires {CustomEvent} validated - Fired whenever the field is validated.
  *
  * @extends HTMLElement
  * @mixes ComboBoxDataProviderMixin
  * @mixes ComboBoxMixin
  * @mixes ThemableMixin
+ * @mixes ValidateMixin
  */
-class ComboBoxLight extends ComboBoxDataProviderMixin(ComboBoxMixin(ThemableMixin(PolymerElement))) {
+class ComboBoxLight extends ComboBoxDataProviderMixin(ComboBoxMixin(ValidateMixin(ThemableMixin(PolymerElement)))) {
   static get is() {
     return 'vaadin-combo-box-light';
   }

package/src/vaadin-combo-box-mixin.d.ts

@@ -3,11 +3,11 @@
  * Copyright (c) 2015 - 2022 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { Constructor } from '@open-wc/dedupe-mixin';
-import { DisabledMixinClass } from '@vaadin/component-base/src/disabled-mixin.js';
-import { KeyboardMixinClass } from '@vaadin/component-base/src/keyboard-mixin.js';
-import { InputMixinClass } from '@vaadin/field-base/src/input-mixin.js';
-import { ComboBox } from './vaadin-combo-box.js';
+import type { Constructor } from '@open-wc/dedupe-mixin';
+import type { DisabledMixinClass } from '@vaadin/component-base/src/disabled-mixin.js';
+import type { KeyboardMixinClass } from '@vaadin/component-base/src/keyboard-mixin.js';
+import type { InputMixinClass } from '@vaadin/field-base/src/input-mixin.js';
+import type { ComboBox } from './vaadin-combo-box.js';
 
 export type ComboBoxDefaultItem = any;
 
@@ -24,11 +24,11 @@ export type ComboBoxRenderer<TItem> = (
 
 export declare function ComboBoxMixin<TItem, T extends Constructor<HTMLElement>>(
   base: T,
-): T &
-  Constructor<ComboBoxMixinClass<TItem>> &
+): Constructor<ComboBoxMixinClass<TItem>> &
   Constructor<DisabledMixinClass> &
   Constructor<InputMixinClass> &
-  Constructor<KeyboardMixinClass>;
+  Constructor<KeyboardMixinClass> &
+  T;
 
 export declare class ComboBoxMixinClass<TItem> {
   /**
@@ -138,11 +138,6 @@ export declare class ComboBoxMixinClass<TItem> {
    */
   itemIdPath: string | null | undefined;
 
-  /**
-   * Set to true if the value is invalid.
-   */
-  invalid: boolean;
-
   protected readonly _propertyForValue: string;
 
   protected _inputElementValue: string | undefined;
@@ -170,16 +165,5 @@ export declare class ComboBoxMixinClass<TItem> {
    */
   close(): void;
 
-  /**
-   * Returns true if `value` is valid, and sets the `invalid` flag appropriately.
-   */
-  validate(): boolean;
-
-  /**
-   * Returns true if the current input value satisfies all constraints (if any).
-   * You can override this method for custom validations.
-   */
-  checkValidity(): boolean;
-
   protected _revertInputValue(): void;
 }

package/src/vaadin-combo-box-mixin.js

@@ -6,6 +6,7 @@
 import { isTouch } from '@vaadin/component-base/src/browser-utils.js';
 import { ControllerMixin } from '@vaadin/component-base/src/controller-mixin.js';
 import { DisabledMixin } from '@vaadin/component-base/src/disabled-mixin.js';
+import { isElementFocused } from '@vaadin/component-base/src/focus-utils.js';
 import { KeyboardMixin } from '@vaadin/component-base/src/keyboard-mixin.js';
 import { processTemplates } from '@vaadin/component-base/src/templates.js';
 import { InputMixin } from '@vaadin/field-base/src/input-mixin.js';
@@ -236,7 +237,6 @@ export const ComboBoxMixin = (subclass) =>
 
     static get observers() {
       return [
-        '_filterChanged(filter, itemValuePath, itemLabelPath)',
         '_selectedItemChanged(selectedItem, itemValuePath, itemLabelPath)',
         '_openedOrItemsChanged(opened, filteredItems, loading)',
         '_updateScroller(_scroller, filteredItems, opened, loading, selectedItem, itemIdPath, _focusedIndex, renderer, theme)',
@@ -382,6 +382,25 @@ export const ComboBoxMixin = (subclass) =>
       this.opened = false;
     }
 
+    /**
+     * Override Polymer lifecycle callback to handle `filter` property change after
+     * the observer for `opened` property is triggered. This is needed when opening
+     * combo-box on user input to ensure the focused index is set correctly.
+     *
+     * @param {!Object} currentProps Current accessor values
+     * @param {?Object} changedProps Properties changed since the last call
+     * @param {?Object} oldProps Previous values for each changed property
+     * @protected
+     * @override
+     */
+    _propertiesChanged(currentProps, changedProps, oldProps) {
+      super._propertiesChanged(currentProps, changedProps, oldProps);
+
+      if (changedProps.filter !== undefined) {
+        this._filterChanged(changedProps.filter);
+      }
+    }
+
     /** @private */
     _initOverlay() {
       const overlay = this.$.overlay;
@@ -395,11 +414,6 @@ export const ComboBoxMixin = (subclass) =>
       // Prevent blurring the input when clicking inside the overlay
       overlay.addEventListener('mousedown', (e) => e.preventDefault());
 
-      // Preventing the default modal behavior of the overlay on input click
-      overlay.addEventListener('vaadin-overlay-outside-click', (e) => {
-        e.preventDefault();
-      });
-
       // Manual two-way binding for the overlay "opened" property
       overlay.addEventListener('opened-changed', (e) => {
         this._overlayOpened = e.detail.value;
@@ -442,6 +456,11 @@ export const ComboBoxMixin = (subclass) =>
     // eslint-disable-next-line max-params
     _updateScroller(scroller, items, opened, loading, selectedItem, itemIdPath, focusedIndex, renderer, theme) {
       if (scroller) {
+        if (opened) {
+          scroller.style.maxHeight =
+            getComputedStyle(this).getPropertyValue(`--${this._tagNamePrefix}-overlay-max-height`) || '65vh';
+        }
+
         scroller.setProperties({
           items: opened ? items : [],
           opened,
@@ -488,6 +507,11 @@ export const ComboBoxMixin = (subclass) =>
       this._updateActiveDescendant(index);
     }
 
+    /** @protected */
+    _isInputFocused() {
+      return this.inputElement && isElementFocused(this.inputElement);
+    }
+
     /** @private */
     _updateActiveDescendant(index) {
       const input = this.inputElement;
@@ -514,14 +538,14 @@ export const ComboBoxMixin = (subclass) =>
         this._openedWithFocusRing = this.hasAttribute('focus-ring');
         // For touch devices, we don't want to popup virtual keyboard
         // unless input element is explicitly focused by the user.
-        if (!this.hasAttribute('focused') && !isTouch) {
+        if (!this._isInputFocused() && !isTouch) {
           this.focus();
         }
 
         this.$.overlay.restoreFocusOnClose = true;
       } else {
         this._onClosed();
-        if (this._openedWithFocusRing && this.hasAttribute('focused')) {
+        if (this._openedWithFocusRing && this._isInputFocused()) {
           this.setAttribute('focus-ring', '');
         }
       }
@@ -595,8 +619,6 @@ export const ComboBoxMixin = (subclass) =>
 
     /** @private */
     _onClick(e) {
-      this._closeOnBlurIsPrevented = true;
-
       const path = e.composedPath();
 
       if (this._isClearButton(e)) {
@@ -606,8 +628,6 @@ export const ComboBoxMixin = (subclass) =>
       } else {
         this._onHostClick(e);
       }
-
-      this._closeOnBlurIsPrevented = false;
     }
 
     /**
@@ -623,16 +643,12 @@ export const ComboBoxMixin = (subclass) =>
       if (e.key === 'Tab') {
         this.$.overlay.restoreFocusOnClose = false;
       } else if (e.key === 'ArrowDown') {
-        this._closeOnBlurIsPrevented = true;
         this._onArrowDown();
-        this._closeOnBlurIsPrevented = false;
 
         // Prevent caret from moving
         e.preventDefault();
       } else if (e.key === 'ArrowUp') {
-        this._closeOnBlurIsPrevented = true;
         this._onArrowUp();
-        this._closeOnBlurIsPrevented = false;
 
         // Prevent caret from moving
         e.preventDefault();
@@ -703,8 +719,7 @@ export const ComboBoxMixin = (subclass) =>
       // and there's no need to modify the selection range if the input isn't focused anyway.
       // This affects Safari. When the overlay is open, and then hitting tab, browser should focus
       // the next focusable element instead of the combo-box itself.
-      // Checking the focused property here is enough instead of checking the activeElement.
-      if (this.hasAttribute('focused')) {
+      if (this._isInputFocused() && this.inputElement.setSelectionRange) {
         this.inputElement.setSelectionRange(start, end);
       }
     }
@@ -814,7 +829,7 @@ export const ComboBoxMixin = (subclass) =>
         toggleElement.addEventListener('mousedown', (e) => e.preventDefault());
         // Unfocus previously focused element if focus is not inside combo box (on touch devices)
         toggleElement.addEventListener('click', () => {
-          if (isTouch && !this.hasAttribute('focused')) {
+          if (isTouch && !this._isInputFocused()) {
             document.activeElement.blur();
           }
         });
@@ -849,10 +864,6 @@ export const ComboBoxMixin = (subclass) =>
     _onOpened() {
       // Defer scroll position adjustment to improve performance.
       requestAnimationFrame(() => {
-        // When opened is set as attribute, this logic needs to be delayed until scroller is created.
-        this._scroller.style.maxHeight =
-          getComputedStyle(this).getPropertyValue(`--${this._tagNamePrefix}-overlay-max-height`) || '65vh';
-
         this._scrollIntoView(this._focusedIndex);
 
         // Set attribute after the items are rendered when overlay is opened for the first time.
@@ -925,9 +936,7 @@ export const ComboBoxMixin = (subclass) =>
 
       this._clearSelectionRange();
 
-      if (!this.dataProvider) {
-        this.filter = '';
-      }
+      this.filter = '';
     }
 
     /**
@@ -945,19 +954,27 @@ export const ComboBoxMixin = (subclass) =>
      * @override
      */
     _onInput(event) {
-      if (!this.opened && !this._isClearButton(event) && !this.autoOpenDisabled) {
-        this.open();
-      }
+      const filter = this._inputElementValue;
 
-      const value = this._inputElementValue;
-      if (this.filter === value) {
+      // When opening dropdown on user input, both `opened` and `filter` properties are set.
+      // Perform a batched property update instead of relying on sync property observers.
+      // This is necessary to avoid an extra data-provider request for loading first page.
+      const props = {};
+
+      if (this.filter === filter) {
         // Filter and input value might get out of sync, while keyboard navigating for example.
         // Afterwards, input value might be changed to the same value as used in filtering.
         // In situation like these, we need to make sure all the filter changes handlers are run.
-        this._filterChanged(this.filter, this.itemValuePath, this.itemLabelPath);
+        this._filterChanged(this.filter);
       } else {
-        this.filter = value;
+        props.filter = filter;
       }
+
+      if (!this.opened && !this._isClearButton(event) && !this.autoOpenDisabled) {
+        props.opened = true;
+      }
+
+      this.setProperties(props);
     }
 
     /**
@@ -980,11 +997,7 @@ export const ComboBoxMixin = (subclass) =>
     }
 
     /** @private */
-    _filterChanged(filter, _itemValuePath, _itemLabelPath) {
-      if (filter === undefined) {
-        return;
-      }
-
+    _filterChanged(filter) {
       // Scroll to the top of the list whenever the filter changes.
       this._scrollIntoView(0);
 
@@ -1063,14 +1076,11 @@ export const ComboBoxMixin = (subclass) =>
       }
 
       if (isValidValue(value)) {
-        let item;
         if (this._getItemValue(this.selectedItem) !== value) {
           this._selectItemForValue(value);
-        } else {
-          item = this.selectedItem;
         }
 
-        if (!item && this.allowCustomValue) {
+        if (!this.selectedItem && this.allowCustomValue) {
           this._inputElementValue = value;
         }
 
@@ -1078,6 +1088,9 @@ export const ComboBoxMixin = (subclass) =>
       } else {
         this.selectedItem = null;
       }
+
+      this.filter = '';
+
       // In the next _detectAndDispatchChange() call, the change detection should pass
       this._lastCommittedValue = undefined;
     }
@@ -1276,35 +1289,12 @@ export const ComboBoxMixin = (subclass) =>
       this._clear();
     }
 
-    /**
-     * Returns true if `value` is valid, and sets the `invalid` flag appropriately.
-     *
-     * @return {boolean} True if the value is valid and sets the `invalid` flag appropriately
-     */
-    validate() {
-      return !(this.invalid = !this.checkValidity());
-    }
-
-    /**
-     * Returns true if the current input value satisfies all constraints (if any).
-     * You can override this method for custom validations.
-     *
-     * @return {boolean}
-     */
-    checkValidity() {
-      if (super.checkValidity) {
-        return super.checkValidity();
-      }
-
-      return !this.required || !!this.value;
-    }
-
     /**
      * Fired when the value changes.
      *
      * @event value-changed
      * @param {Object} detail
-     *  @param {String} detail.value the combobox value
+     * @param {String} detail.value the combobox value
      */
 
     /**
@@ -1312,7 +1302,7 @@ export const ComboBoxMixin = (subclass) =>
      *
      * @event selected-item-changed
      * @param {Object} detail
-     *  @param {Object|String} detail.value the selected item. Type is the same as the type of `items`.
+     * @param {Object|String} detail.value the selected item. Type is the same as the type of `items`.
      */
 
     /**

package/src/vaadin-combo-box-scroller.js

@@ -250,7 +250,7 @@ export class ComboBoxScroller extends PolymerElement {
   /** @private */
   __loadingChanged() {
     if (this.__virtualizer) {
-      this.requestContentUpdate();
+      setTimeout(() => this.requestContentUpdate());
     }
   }